@dotrino/vault 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",
@@ -43,7 +43,7 @@
   ],
   "peerDependencies": {
     "@dotrino/identity": ">=0.30.0",
-    "@dotrino/proxy-client": ">=0.6.0"
+    "@dotrino/proxy-client": ">=0.9.0"
   },
   "license": "MIT",
   "repository": {

package/src/enroll.js

@@ -39,6 +39,8 @@ export const FRESH_WINDOW_MS = 5 * 60 * 1000
 /** Vida por defecto del cert de un dispositivo (tope duro de `MAX_DELEGATION_MS`). */
 export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 
+export const MSG_HELLO = 'vault.hello'
+export const MSG_HELLO_OK = 'vault.hello.ok'
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
@@ -112,7 +114,10 @@ export function createEnrollDesk ({
   defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
   // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
   // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
-  encPub = null, vaultLabel = ''
+  encPub = null, vaultLabel = '',
+  // Token de CONEXIÓN de esta bóveda en el proxy (4 chars): su dirección. Es lo
+  // único que necesita el QR corto para que el aparato le hable punto a punto.
+  connToken = null
 } = {}) {
   if (!identity) throw new Error('createEnrollDesk: falta identity')
   if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
@@ -141,11 +146,27 @@ export function createEnrollDesk ({
    *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
    *                       identidad de verdad de la cuenta es `iss`.
    */
-  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
+    const acct = String(account || '').slice(0, 40)
+    // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
+    // nonce de la sesión. La llave, el proxy y el nombre de la cuenta los pide el
+    // aparato por la red presentando el `sn`. El nonce hace de identificador de
+    // sesión: no hace falta un token de emparejamiento aparte.
+    //
+    // `conn` es una CITA del proxio (6 caracteres, un solo uso, caduca en
+    // minutos), no la dirección de la conexión: esa pasó a ser una instancia de
+    // 24 caracteres, que ni entra cómoda en un QR ni tiene por qué quedar impresa
+    // en algo que circula. Por eso se pide una nueva por emparejamiento, y por
+    // eso esto es asíncrono.
+    const conn = typeof connToken === 'function' ? await connToken() : connToken
+    if (conn) {
+      const sn = randToken(8)
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
+    }
     const token = randToken(PAIR_TOKEN_BYTES)
     const sn = randToken(PAIR_TOKEN_BYTES)
-    const acct = String(account || '').slice(0, 40)
     pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
@@ -165,6 +186,28 @@ export function createEnrollDesk ({
     return null
   }
 
+  /**
+   * «¿Quién eres?» — la respuesta al QR corto. Solo se contesta a quien presente el
+   * `sn` de una sesión VIVA: el token de conexión son 4 caracteres y se puede acertar
+   * a ciegas, el `sn` no. Fuera de un emparejamiento no hay ninguna sesión y por lo
+   * tanto no hay respuesta: la puerta solo está abierta mientras dura el `pair`.
+   */
+  async function handleHello (from, p) {
+    const pend = pending.get(String(p?.sn || ''))
+    if (!pend || Date.now() > pend.exp) {
+      audit('rejected', { what: 'hello', reason: 'sin-sesion' })
+      return reply(from, { type: MSG_ERROR, error: 'no hay ningún emparejamiento abierto con ese código' })
+    }
+    // La respuesta va FIRMADA por la maestra y el `sn` va dentro de lo firmado. Eso ata
+    // la respuesta a ESTA sesión: no se puede reutilizar la de otro emparejamiento ni la
+    // de otra bóveda. Lo que NO hace es demostrar que sea TU bóveda —cualquiera puede
+    // firmar con una llave suya—; eso solo lo demuestra el código de 6 dígitos.
+    const body = { op: 'hello', sn: pend.sn, iss, proxy, acct: pend.account || '', m: pend.mode || 'join', ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    reply(from, { type: MSG_HELLO_OK, body, signature })
+    return { ok: true }
+  }
+
   /**
    * ENROLL: el dispositivo prueba posesión de `D` firmando el sobre y deja el
    * COMPROMISO de su código. Todavía NO se firma ningún cert.
@@ -399,7 +442,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, handleActaSealed, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, handleHello, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/src/invite.js

@@ -49,6 +49,21 @@
 export const FMT_JSON = 'j'
 export const FMT_B64 = 'b'
 export const FMT_COMPACT = 'c'
+/**
+ * `t` — la invitación CORTA: solo la dirección y el nonce de la sesión. La llave
+ * maestra ya no viaja; el aparato se la pide a la bóveda por la red presentando el
+ * `sn`, y la comprueba con la firma del certificado y con el código de 6 dígitos,
+ * que es lo único que de verdad decide. Esconderla no aportaba nada —una pública es
+ * pública— y ocupaba 44 de los ~100 caracteres.
+ *
+ * Lo que lleva NO es la dirección de la bóveda: es una **cita del proxy** —un código
+ * de 6 caracteres, de un solo uso y con minutos de vida, cuyos 2 primeros dicen qué
+ * proxio la emitió—. El aparato la CANJEA (`redeemPairingCode`) y obtiene la dirección
+ * real de la conexión, que hoy son 24 caracteres para poder rutearse entre proxios y no
+ * cabría cómoda en un QR. Además, una cita caduca y se quema: no deja una dirección
+ * permanente impresa en algo que circula.
+ */
+export const FMT_SHORT = 't'
 
 /** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
 export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
@@ -266,6 +281,60 @@ function compactDecode (text) {
 // API
 // ---------------------------------------------------------------------------
 
+/**
+ * Blob de la forma CORTA (`t`): cabecera(1) ‖ token de conexión(4 ASCII) ‖ sn(8)
+ * ‖ [len+proxy].
+ *   bits 0-2  versión · bit 3  modo (join/adopt) · bit 4  lleva proxy propio
+ *
+ * Sin llave y sin nombre de cuenta: eso llega en la respuesta de la bóveda, así que
+ * un nombre largo ya no agranda el QR. 13 bytes → 18 caracteres.
+ *
+ * El PROXY sí viaja cuando no es el del ecosistema, y no es opcional: el token de
+ * conexión solo tiene sentido **en el proxy donde se emitió**. Quitarlo hacía que un
+ * aparato se conectara al proxy público y le hablara a un token de otro servidor —
+ * el mensaje no llegaba a ninguna parte y el emparejamiento se quedaba esperando.
+ * Le pasa a cualquiera con proxy propio (y lo cazó el E2E de secretos, que levanta
+ * uno local).
+ */
+// La CITA del proxio: 2 caracteres de prefijo de nodo + 4 = 6. Antes eran 4 (la
+// dirección de la conexión). Cambió porque la dirección pasó a ser una instancia
+// de 24 caracteres, y lo que se imprime en un QR ahora es una cita de un solo uso.
+const CONN_TOKEN_LEN = 6
+
+function shortEncode (qr) {
+  if (!qr || qr.v !== 2) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const conn = String(qr.conn || '')
+  if (conn.length !== CONN_TOKEN_LEN || !/^[\x21-\x7e]+$/.test(conn)) return null
+  if (!/^[0-9a-f]{16}$/.test(qr.sn || '')) return null // 8 bytes
+  const known = new Set(['v', 'conn', 'sn', 'm', 'proxy'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+  const ownProxy = qr.proxy && qr.proxy !== DEFAULT_PROXY
+  const proxy = ownProxy ? utf8(String(qr.proxy)) : null
+  if (proxy && proxy.length > 255) return null
+  const out = [qr.v | (mode << 3) | (ownProxy ? 0x10 : 0), ...[...conn].map((c) => c.charCodeAt(0)), ...hexToBytes(qr.sn)]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function shortDecode (text) {
+  const b = b64urlToBytes(text)
+  if (!b || b.length < 1 + CONN_TOKEN_LEN + 8) return null
+  const head = b[0]
+  if (head & 0xe0) return null
+  let i = 1 + CONN_TOKEN_LEN + 8
+  let proxy = DEFAULT_PROXY
+  if (head & 0x10) {
+    if (i >= b.length) return null
+    const n = b[i]; i += 1
+    if (i + n !== b.length) return null
+    proxy = fromUtf8(b.subarray(i, i + n)); i += n
+  } else if (i !== b.length) return null
+  const conn = String.fromCharCode(...b.subarray(1, 1 + CONN_TOKEN_LEN))
+  return { v: head & 7, conn, sn: bytesToHex(b.subarray(1 + CONN_TOKEN_LEN, 1 + CONN_TOKEN_LEN + 8)), m: MODES[(head >> 3) & 1], proxy }
+}
+
 /** Comparación por contenido, sin depender del orden de las claves. */
 const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
 
@@ -278,6 +347,11 @@ const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
  */
 export function encodeInvite (qr, fmt = FMT_COMPACT) {
   const json = JSON.stringify(qr)
+  // La forma corta se emite cuando el QR trae dirección en vez de llave.
+  if (qr && qr.conn) {
+    const t = shortEncode(qr)
+    if (t) { const back = shortDecode(t); if (back && canon(back) === canon(qr)) return FMT_SHORT + t }
+  }
   if (fmt === FMT_JSON) return FMT_JSON + json
   if (fmt === FMT_COMPACT) {
     const c = compactEncode(qr)
@@ -320,6 +394,7 @@ export function parseInvite (text) {
 
   const marca = payload[0]
   const resto = payload.slice(1)
+  if (marca === FMT_SHORT) { const o = shortDecode(resto); if (o) return o }
   if (marca === FMT_COMPACT) { const o = compactDecode(resto); if (o) return o }
   if (marca === FMT_JSON) { const o = parse(undoUrl(resto)) || parse(resto); if (o) return o }
   if (marca === FMT_B64) { const s = b64urlDecodeStr(resto); const o = s && parse(s); if (o) return o }
@@ -331,4 +406,4 @@ export function parseInvite (text) {
   return s ? parse(s) : null
 }
 
-export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, FMT_SHORT, PAIR_URL, DEFAULT_PROXY }

package/src/protocol.js

@@ -17,6 +17,11 @@
  * 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 }

package/src/service.js

@@ -60,6 +60,42 @@ function installNodeGlobals () {
   }
 }
 
+
+/**
+ * La respuesta al `hello` va firmada y con el `sn` DENTRO de lo firmado. Comprobarlo
+ * ata la respuesta a ESTA sesión: no vale la de otro emparejamiento ni la de otra
+ * bóveda. Ojo con lo que NO prueba: cualquiera puede firmar con una llave suya, así
+ * que esto no dice que sea TU bóveda — eso lo dice el código de 6 dígitos, que solo
+ * aprende la bóveda donde tú lo tecleas.
+ */
+async function verificarHola (p, sn) {
+  const b = p?.body
+  if (!b?.iss || b.sn !== sn) throw new Error('la bóveda contestó a otro emparejamiento')
+  if (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
+    throw new Error('la respuesta de la bóveda no está bien firmada')
+  }
+  return b
+}
+
+/**
+ * Canjea la cita del QR y devuelve la instancia a la que apunta.
+ *
+ * Una cita se quema al usarse y caduca en minutos, así que un error acá casi
+ * siempre significa lo mismo para quien lo lee: el código ya se usó o venció, y
+ * hay que pedir otro en la bóveda. Se dice así, no con el error crudo.
+ */
+async function resolverCita (client, code) {
+  if (!code) throw new Error('la invitación no trae código de emparejamiento')
+  if (typeof client.redeemPairingCode !== 'function') {
+    throw new Error('el proxio no soporta códigos de emparejamiento (actualizá @dotrino/proxy-client)')
+  }
+  const r = await client.redeemPairingCode(code)
+  if (!r?.ok || !r.instance) {
+    throw new Error(`ese código no sirve: ${r?.error || 'no válido'}. Pedí uno nuevo en la bóveda.`)
+  }
+  return r.instance
+}
+
 async function freshClient (proxyUrl, connectTimeoutMs = 20000) {
   installNodeGlobals()
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
@@ -132,12 +168,30 @@ function writeServiceIdentity (dir, obj) {
  */
 export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeoutMs = 180000 } = {}) {
   if (typeof qr === 'string') { try { qr = JSON.parse(qr) } catch (_) { throw new Error('qr inválido: no es JSON') } }
-  if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
+  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('qr inválido: falta la bóveda o el nonce')
   if (!isValidSecretsNs(ns)) throw new Error('ns inválido (usa [a-z0-9-]{1,32}, p.ej. "proxy")')
   if (!dir) throw new Error('falta dir (dónde persistir la identidad del servicio)')
   label = label || 'servicio:' + ns
 
-  const client = await freshClient(qr.proxy)
+  const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
+  // QR CORTO: se le pregunta a la bóveda quién es, punto a punto, presentando el `sn`.
+  if (!qr.iss) {
+    // `qr.conn` es una CITA (código de 6 caracteres, un solo uso): hay que
+    // canjearla para saber a qué conexión apunta. El canje lo resuelve el proxio
+    // que la emitió —lo dice el prefijo del propio código—, así que funciona
+    // aunque la bóveda esté en otro proxio de la malla.
+    const destino = await resolverCita(client, qr.conn)
+    const hola = await new Promise((resolve, reject) => {
+      const off = client.on('message', (_f, p) => {
+        if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then(resolve, reject) }
+        else if (p?.type === MSG.ERROR) { fin(); reject(new Error(p.error)) }
+      })
+      const t = setTimeout(() => { fin(); reject(new Error('la bóveda no contestó: ese código pudo caducar')) }, 15000)
+      const fin = () => { off(); clearTimeout(t) }
+      try { client.send(destino, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
+    })
+    qr = { ...qr, iss: hola.iss, proxy: hola.proxy || qr.proxy }
+  }
   try {
     const device = await makeDeviceKey({ label })
     const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
@@ -147,7 +201,7 @@ export async function enrollService ({ qr, ns, dir, label, onCode, approveTimeou
     // El COMPROMISO del código (nunca el código): la bóveda lo recompone con lo que
     // tipeas y solo entonces firma el cert → aprobar exige haber leído esta pantalla.
     const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
-    const data = { op: 'enroll', dpub: device.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
+    const data = { op: 'enroll', dpub: device.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {