@dotrino/vault 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.9.0",
+  "version": "0.10.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",

package/src/enroll.js

@@ -63,12 +63,22 @@ export function scopeToCn (scope) {
   return null
 }
 
-/** Token aleatorio de 128 bits en hex. */
-export function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
+/**
+ * Token aleatorio en hex (16 bytes = 128 bits por defecto).
+ *
+ * El emparejamiento pide 12 (96 bits): son de un solo uso, valen 5 minutos y hay
+ * UNA sesión viva a la vez, así que adivinarlo es 2^95 intentos contra una bóveda
+ * que además exige el código de 6 dígitos. A cambio, cada byte de menos son ~1,4
+ * caracteres menos en el QR — y el QR se mide en filas de terminal.
+ */
+export function randToken (bytes = 16) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes))
   return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/** Tamaño del token/nonce de una sesión de emparejamiento (ver `randToken`). */
+const PAIR_TOKEN_BYTES = 12
+
 /** deviceId legible (p. ej. `C440-AC0E`) a partir de una pubkey JWK. */
 export async function deviceIdOf (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -126,8 +136,8 @@ export function createEnrollDesk ({
    */
   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 token = randToken()
-    const sn = randToken()
+    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 }

package/src/invite.js

@@ -1,65 +1,310 @@
 /**
  * invite.js — la invitación de emparejamiento: cómo se escribe y cómo se lee.
  *
- * Un emparejamiento viaja de dos maneras, y cada una quiere una codificación
- * distinta:
+ * Una invitación viaja de dos maneras —un QR que se escanea y un código que se
+ * copia y se pega— y **las dos quieren lo mismo: que sea CORTA**. En un QR cada
+ * carácter son módulos, y los módulos son filas y columnas de terminal; en un
+ * código pegable, cada carácter es una oportunidad de que alguien lo corte mal.
  *
- *   · **El QR / el enlace** → JSON CRUDO (`j`). Nadie lo lee con los ojos y cada
- *     carácter cuenta: el base64 infla el payload un 33 % y eso son módulos de más
- *     en el QR (~8 columnas y 4 filas de terminal). Va crudo.
- *   · **El código que se copia y se pega** → base64url (`b`). Ahí sí lo manipula
- *     una persona: una sola palabra sin comillas, llaves ni espacios, que sobrevive
- *     a un doble clic, a un chat y a un campo de texto.
+ * Por eso el formato vigente es **`c` (compacto)**: los datos van en BINARIO y el
+ * binario en base64url. Nada de JSON. Un JSON con la llave maestra dentro pesa
+ * ~340 caracteres (la llave es una JWK *serializada como string*, con sus comillas
+ * escapadas: 182 de esos 340 son ella sola); el mismo contenido en binario son ~75
+ * bytes → **~100 caracteres**. Medido en la práctica: el QR pasó de 69 módulos
+ * (77×39 en la terminal) a 41 (49×25), y el código pegable de 458 caracteres a 101.
  *
- * Para que el lector no tenga que ADIVINAR cuál de las dos le llegó, el payload
- * empieza por una **marca de formato** de un carácter (`j` o `b`). Sin marca se
- * asume el formato viejo (base64url, y si no, JSON), solo por compatibilidad con
- * los enlaces que ya salieron.
+ * De dónde sale el ahorro, en orden de importancia:
+ *   · **La llave `iss`** (182 → 44 chars). Una pubkey P-256 son dos coordenadas de
+ *     32 bytes; en el QR va el **punto comprimido** de 33 bytes (SEC1: `02`/`03`
+ *     según la paridad de `y`, seguido de `x`) y el lector recupera `y` resolviendo
+ *     la curva. La JWK se rearma con una PLANTILLA (el índice va en la cabecera)
+ *     para que la string vuelva **byte a byte** igual: el proxy direcciona por esa
+ *     string exacta, así que una coma de más rompe el enrutamiento.
+ *   · **`token` y `sn`** (34+34 → 16+16 bytes): eran hexadecimal, que gasta dos
+ *     caracteres por byte.
+ *   · **`proxy`** (33 → 0): si es el del ecosistema no viaja; se sobreentiende.
+ *   · **`m` y `v`**: dos campos de JSON → dos grupos de bits de la cabecera.
  *
- * GOTCHA que justifica la mitad de este archivo: el JSON crudo lleva `{`, `}` y
- * `"`, que **no son legales en una URI**. Al abrir el enlace, el navegador los
- * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es el JSON
- * que se emitió. Medido en un navegador real (2026-07-28). Por eso se
- * `decodeURIComponent` antes de parsear: sin eso, el QR daba «ese código no vale».
+ * SEGURIDAD DEL AHORRO: `encodeInvite` **comprueba el viaje de vuelta** antes de
+ * entregar la forma compacta — decodifica lo que acaba de codificar y exige que sea
+ * idéntico al original. Si algo no encaja (una JWK con otra forma, un campo nuevo,
+ * un `token` que no es hex), devuelve la forma larga en base64. Así una llave rara
+ * no rompe un emparejamiento: como mucho lo hace más grande.
+ *
+ * Formatos que se leen (el primer carácter dice cuál es):
+ *   · `c` — compacto binario+base64url. **El que se emite hoy**, para el QR y para
+ *           el código pegable: es a la vez el más corto y una sola palabra sin
+ *           comillas ni llaves, que sobrevive a un doble clic y a un chat.
+ *   · `b` — base64url del JSON. Forma larga, de reserva.
+ *   · `j` — JSON crudo. Solo para leer enlaces ya emitidos.
+ *   · sin marca — anterior a la marca de formato (base64url, o JSON).
+ *
+ * GOTCHA que justifica el `decodeURIComponent`: el JSON crudo lleva `{`, `}` y `"`,
+ * que **no son legales en una URI**. Al abrir el enlace, el navegador los
+ * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es lo que se
+ * emitió. Medido en un navegador real (2026-07-28). El formato compacto no tiene
+ * ese problema —base64url ya es seguro en una URL—, pero `j` sigue por ahí.
  */
 
 export const FMT_JSON = 'j'
 export const FMT_B64 = 'b'
+export const FMT_COMPACT = 'c'
+
+/** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
+export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
+
+/**
+ * La base del enlace del QR. Corta a propósito (`/d#v=` en vez de
+ * `/dispositivos#vault=`): son 15 caracteres menos dentro del QR, y ahí los
+ * caracteres se pagan en módulos. `vault.dotrino.com/dispositivos` sigue
+ * funcionando —es la ruta que la gente ya tiene— y `parseInvite` lee las dos.
+ */
+export const PAIR_URL = 'https://vault.dotrino.com/d#v='
+
+// ---------------------------------------------------------------------------
+// Conversiones (sin dependencias: esto corre en el navegador, en Node y dentro
+// del binario SEA)
+// ---------------------------------------------------------------------------
+
+const B64_STD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
 
-const b64urlEncode = (s) => {
-  const bytes = new TextEncoder().encode(s)
-  let bin = ''
-  for (const b of bytes) bin += String.fromCharCode(b)
-  const raw = typeof btoa === 'function' ? btoa(bin) : Buffer.from(s, 'utf8').toString('base64')
-  return raw.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+function bytesToB64url (bytes) {
+  let out = ''
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i]; const b = bytes[i + 1]; const c = bytes[i + 2]
+    out += B64_STD[a >> 2]
+    out += B64_STD[((a & 3) << 4) | ((b ?? 0) >> 4)]
+    if (b === undefined) break
+    out += B64_STD[((b & 15) << 2) | ((c ?? 0) >> 6)]
+    if (c === undefined) break
+    out += B64_STD[c & 63]
+  }
+  return out.replace(/\+/g, '-').replace(/\//g, '_')
 }
 
-const b64urlDecode = (s) => {
-  const b = s.replace(/-/g, '+').replace(/_/g, '/')
-  const pad = b + '='.repeat((4 - b.length % 4) % 4)
-  if (typeof atob === 'function') {
-    const bin = atob(pad)
-    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0))
-    return new TextDecoder().decode(bytes)
+function b64urlToBytes (s) {
+  const clean = String(s).replace(/-/g, '+').replace(/_/g, '/').replace(/[^A-Za-z0-9+/]/g, '')
+  const out = []
+  let acc = 0; let bits = 0
+  for (const ch of clean) {
+    const v = B64_STD.indexOf(ch)
+    if (v < 0) return null
+    acc = (acc << 6) | v; bits += 6
+    if (bits >= 8) { bits -= 8; out.push((acc >> bits) & 0xff) }
   }
-  return Buffer.from(pad, 'base64').toString('utf8')
+  return Uint8Array.from(out)
 }
 
-/** El payload marcado, listo para meter en el `#fragment` o para copiar y pegar. */
-export function encodeInvite (qr, fmt = FMT_B64) {
+const utf8 = (s) => new TextEncoder().encode(s)
+const fromUtf8 = (b) => new TextDecoder().decode(b)
+
+/**
+ * `token` y `sn` son hexadecimal. Caben en la invitación en dos tamaños —12 o 16
+ * bytes— porque el hexadecimal gasta dos caracteres por byte y en un QR eso se
+ * paga: 12 bytes (96 bits, lo que emite hoy `startPairing`) son 11 caracteres
+ * menos que 16, y esos 11 caracteres son la diferencia entre que quepa un nombre
+ * de cuenta normal o que el QR suba una versión entera.
+ */
+const hexLen = (s) => (typeof s === 'string' && /^[0-9a-f]+$/.test(s) && (s.length === 24 || s.length === 32)) ? s.length / 2 : 0
+const hexToBytes = (s) => Uint8Array.from(s.match(/../g).map((h) => parseInt(h, 16)))
+const bytesToHex = (b) => [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
+
+const b64urlEncodeStr = (s) => bytesToB64url(utf8(s))
+const b64urlDecodeStr = (s) => { const b = b64urlToBytes(s); return b ? fromUtf8(b) : null }
+
+// ---------------------------------------------------------------------------
+// La llave maestra: JWK ⇄ punto comprimido de la curva P-256
+// ---------------------------------------------------------------------------
+
+/**
+ * Las formas de JWK que existen en el ecosistema. `JSON.stringify` de una JWK
+ * conserva el orden en que la exportó cada WebCrypto, y **ese orden es parte de la
+ * identidad**: el proxy direcciona por la string exacta. Por eso no se «normaliza»
+ * la JWK —eso cambiaría la dirección de la bóveda—, se rearma tal cual con la
+ * plantilla que le toca. El índice viaja en la cabecera (2 bits, hasta 4 formas).
+ */
+const JWK_TEMPLATES = [
+  // 0 — WebCrypto de Node (el daemon del PC): key_ops, ext, kty, x, y, crv
+  (x, y) => `{"key_ops":["verify"],"ext":true,"kty":"EC","x":"${x}","y":"${y}","crv":"P-256"}`,
+  // 1 — WebCrypto de navegador (Chrome/Firefox/Safari, alfabético): crv, ext, key_ops, kty, x, y
+  (x, y) => `{"crv":"P-256","ext":true,"key_ops":["verify"],"kty":"EC","x":"${x}","y":"${y}"}`,
+]
+
+// Parámetros de la curva P-256 (FIPS 186-4). `a` es −3.
+const P256_P = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn
+const P256_B = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn
+
+const modPow = (base, exp, m) => {
+  let r = 1n; let b = base % m
+  while (exp > 0n) { if (exp & 1n) r = (r * b) % m; b = (b * b) % m; exp >>= 1n }
+  return r
+}
+
+const bytesToBig = (b) => { let n = 0n; for (const x of b) n = (n << 8n) | BigInt(x); return n }
+const bigToBytes32 = (n) => { const out = new Uint8Array(32); for (let i = 31; i >= 0; i--) { out[i] = Number(n & 0xffn); n >>= 8n } return out }
+
+/** Coordenada de una JWK: base64url de 32 bytes exactos, o `null`. */
+function coordBytes (s) {
+  if (typeof s !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(s)) return null
+  const b = b64urlToBytes(s)
+  return b && b.length === 32 ? b : null
+}
+
+/**
+ * `iss` (JWK serializada) → `{ tpl, point }` con el punto comprimido de 33 bytes, o
+ * `null` si la llave no tiene una forma conocida (entonces la invitación va larga).
+ */
+function packPubkey (iss) {
+  if (typeof iss !== 'string') return null
+  let jwk
+  try { jwk = JSON.parse(iss) } catch { return null }
+  if (!jwk || jwk.kty !== 'EC' || jwk.crv !== 'P-256') return null
+  const xb = coordBytes(jwk.x); const yb = coordBytes(jwk.y)
+  if (!xb || !yb) return null
+
+  const tpl = JWK_TEMPLATES.findIndex((f) => f(jwk.x, jwk.y) === iss)
+  if (tpl < 0) return null // forma desconocida: no se puede rearmar igual → larga
+
+  const point = new Uint8Array(33)
+  point[0] = 2 + (yb[31] & 1) // 02 = y par, 03 = y impar
+  point.set(xb, 1)
+  return { tpl, point }
+}
+
+/** Punto comprimido + plantilla → la `iss` original (o `null` si el punto no es de la curva). */
+function unpackPubkey (point, tpl) {
+  const template = JWK_TEMPLATES[tpl]
+  if (!template || point.length !== 33 || (point[0] !== 2 && point[0] !== 3)) return null
+
+  const x = bytesToBig(point.subarray(1))
+  if (x >= P256_P) return null
+  // y² = x³ − 3x + b (mod p). Con p ≡ 3 (mod 4) la raíz es y = (y²)^((p+1)/4).
+  const y2 = (((x * x) % P256_P) * x - 3n * x + P256_B) % P256_P
+  const rhs = (y2 + P256_P) % P256_P
+  let y = modPow(rhs, (P256_P + 1n) / 4n, P256_P)
+  if ((y * y) % P256_P !== rhs) return null // x no está en la curva
+  if ((y & 1n) !== BigInt(point[0] & 1)) y = P256_P - y
+
+  return template(bytesToB64url(point.subarray(1)), bytesToB64url(bigToBytes32(y)))
+}
+
+// ---------------------------------------------------------------------------
+// El formato compacto
+// ---------------------------------------------------------------------------
+
+/**
+ * Cabecera (1 byte):
+ *   bits 0-2  versión del protocolo (`qr.v`, hoy 2)
+ *   bit  3    modo: 0 = `join` · 1 = `adopt`
+ *   bits 4-5  plantilla de la JWK (índice en `JWK_TEMPLATES`)
+ *   bit  6    lleva proxy propio (si no, el del ecosistema)
+ *   bit  7    `token`/`sn` de 12 bytes (si 0, de 16)
+ *
+ * Cuerpo: punto comprimido (33) ‖ token (n) ‖ sn (n) ‖ len+`acct` ‖ [len+`proxy`]
+ */
+const MODES = ['join', 'adopt']
+
+function compactEncode (qr) {
+  if (!qr || typeof qr !== 'object') return null
+  const v = qr.v
+  if (!Number.isInteger(v) || v < 0 || v > 7) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const n = hexLen(qr.token)
+  if (!n || hexLen(qr.sn) !== n) return null
+
+  const pub = packPubkey(qr.iss)
+  if (!pub || pub.tpl > 3) return null
+
+  const acct = utf8(String(qr.acct || ''))
+  if (acct.length > 255) 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
+
+  // Un campo que no se sepa escribir se perdería en silencio: eso NO se hace.
+  const known = new Set(['v', 'iss', 'proxy', 'token', 'sn', 'm', 'acct'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+
+  const head = v | (mode << 3) | (pub.tpl << 4) | (ownProxy ? 0x40 : 0) | (n === 12 ? 0x80 : 0)
+  const out = [head, ...pub.point, ...hexToBytes(qr.token), ...hexToBytes(qr.sn), acct.length, ...acct]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function compactDecode (text) {
+  const b = b64urlToBytes(text)
+  const n = (b && (b[0] & 0x80)) ? 12 : 16
+  if (!b || b.length < 35 + n * 2) return null
+  const head = b[0]
+
+  const iss = unpackPubkey(b.subarray(1, 34), (head >> 4) & 3)
+  if (!iss) return null
+
+  let i = 34
+  const token = bytesToHex(b.subarray(i, i + n)); i += n
+  const sn = bytesToHex(b.subarray(i, i + n)); i += n
+  const acctLen = b[i]; i += 1
+  if (i + acctLen > b.length) return null
+  const acct = acctLen ? fromUtf8(b.subarray(i, i + acctLen)) : ''
+  i += acctLen
+
+  let proxy = DEFAULT_PROXY
+  if (head & 0x40) {
+    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
+  }
+  if (i !== b.length) return null // sobran bytes: no es lo que creemos que es
+
+  // Mismo orden de campos que `startPairing`, para que las dos formas serialicen igual.
+  return { v: head & 7, iss, proxy, token, sn, m: MODES[(head >> 3) & 1], ...(acct ? { acct } : {}) }
+}
+
+// ---------------------------------------------------------------------------
+// API
+// ---------------------------------------------------------------------------
+
+/** 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]]))
+
+/**
+ * El payload marcado, listo para meter en el `#fragment` o para copiar y pegar.
+ *
+ * Por defecto **compacto**, que es lo más corto y a la vez pegable. Se cae a la
+ * forma larga (`b`) sola, sin avisar, si el compacto no reproduce el original
+ * exactamente: más vale un QR grande que uno que no empareja.
+ */
+export function encodeInvite (qr, fmt = FMT_COMPACT) {
   const json = JSON.stringify(qr)
-  return fmt === FMT_JSON ? FMT_JSON + json : FMT_B64 + b64urlEncode(json)
+  if (fmt === FMT_JSON) return FMT_JSON + json
+  if (fmt === FMT_COMPACT) {
+    const c = compactEncode(qr)
+    // El viaje de vuelta se comprueba SIEMPRE: es barato (una vez por
+    // emparejamiento) y es lo que permite comprimir sin jugarse el enrolamiento.
+    if (c) { const back = compactDecode(c); if (back && canon(back) === canon(qr)) return FMT_COMPACT + c }
+  }
+  return FMT_B64 + b64urlEncodeStr(json)
 }
 
-/** Una URL sin percent-encodear rompe el `#`: el fragmento se corta ahí. */
+/** El enlace del QR: `https://vault.dotrino.com/d#v=<invitación>`. */
+export function inviteUrl (qr) { return PAIR_URL + encodeInvite(qr) }
+
+/**
+ * Corta el `#fragment` de una URL. `#vault=` es la forma larga histórica y `#v=` la
+ * corta de hoy; se prueba la larga primero porque `#vault=` empieza por `#v`.
+ */
 const cutFragment = (text) => {
-  const i = text.indexOf('#vault=')
-  return i >= 0 ? text.slice(i + 7) : text
+  const long = text.indexOf('#vault=')
+  if (long >= 0) return text.slice(long + 7)
+  const short = text.indexOf('#v=')
+  return short >= 0 ? text.slice(short + 3) : text
 }
 
 /**
- * Lee una invitación venga como venga: URL con `#vault=…`, el código suelto, con
- * marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
+ * Lee una invitación venga como venga: URL con `#v=`/`#vault=`, el código suelto,
+ * con marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
  * `null` — nunca lanza, porque del otro lado hay alguien pegando texto a mano.
  */
 export function parseInvite (text) {
@@ -75,13 +320,15 @@ export function parseInvite (text) {
 
   const marca = payload[0]
   const resto = payload.slice(1)
-  if (marca === FMT_JSON) return parse(undoUrl(resto)) || parse(resto)
-  if (marca === FMT_B64) { try { return parse(b64urlDecode(resto)) } catch { return null } }
+  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 }
 
   // --- sin marca: formatos anteriores a la marca de formato (compatibilidad) ---
   const crudo = undoUrl(payload)
   if (crudo.trimStart().startsWith('{')) return parse(crudo)
-  try { return parse(b64urlDecode(payload)) } catch { return null }
+  const s = b64urlDecodeStr(payload)
+  return s ? parse(s) : null
 }
 
-export default { encodeInvite, parseInvite, FMT_JSON, FMT_B64 }
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }