@dotrino/identity 0.114.1 → 0.116.0

package/vault/vendor/passmanager/webauthn.js

@@ -0,0 +1,221 @@
+// Passkeys: crear una credencial WebAuthn y firmar con ella.
+//
+// Chrome NO expone API de proveedor de credenciales a las extensiones (Android 14+ e
+// iOS 17+ sí). En el escritorio la única vía es la que usan todos: reemplazar
+// `navigator.credentials.create/get` en el contexto de la página. Como la llave la
+// generamos nosotros y la firma la producimos nosotros, la assertion es válida y el
+// sitio no distingue.
+//
+// Este módulo es la parte que NO toca el DOM: qué se guarda y cómo se firma. El parche
+// vive en la extensión.
+//
+// Referencia: WebAuthn Level 2, §6.3 (authenticatorMakeCredential) y §6.3.3
+// (authenticatorGetAssertion). El formato importa hasta el bit: un `authenticatorData`
+// mal armado lo rechaza el servidor sin decir por qué.
+
+const subtle = () => globalThis.crypto.subtle
+const enc = new TextEncoder()
+
+export const AAGUID = new Uint8Array(16) // ceros: sin atestación, como todo proveedor de software
+
+export function b64urlEncode (bytes) {
+  let s = ''
+  for (const b of new Uint8Array(bytes)) s += String.fromCharCode(b)
+  return btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+export function b64urlDecode (str) {
+  const b64 = String(str).replace(/-/g, '+').replace(/_/g, '/')
+  const bin = atob(b64)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+function concat (...arrays) {
+  const total = arrays.reduce((n, a) => n + a.length, 0)
+  const out = new Uint8Array(total)
+  let i = 0
+  for (const a of arrays) { out.set(a, i); i += a.length }
+  return out
+}
+
+async function sha256 (bytes) {
+  return new Uint8Array(await subtle().digest('SHA-256', bytes))
+}
+
+/** Banderas del authenticatorData. UP = presencia, UV = verificación, AT = trae credencial. */
+export const FLAGS = { UP: 0x01, UV: 0x04, AT: 0x40 }
+
+/**
+ * `authenticatorData`: hash del rpId + banderas + contador (+ la credencial al crear).
+ * El orden y los tamaños son fijos; aquí no hay margen de interpretación.
+ */
+export async function makeAuthenticatorData ({ rpId, flags, signCount, attested = null }) {
+  const rpIdHash = await sha256(enc.encode(rpId))
+  const counter = new Uint8Array(4)
+  new DataView(counter.buffer).setUint32(0, signCount >>> 0, false) // big-endian
+  const header = concat(rpIdHash, new Uint8Array([flags]), counter)
+  return attested ? concat(header, attested) : header
+}
+
+/** COSE_Key de una pública P-256 (kty 2, alg -7, crv 1). Es lo que el servidor guarda. */
+export function coseFromJwk (jwk) {
+  const x = b64urlDecode(jwk.x)
+  const y = b64urlDecode(jwk.y)
+  // CBOR a mano: un mapa de 5 entradas con claves enteras. La alternativa era arrastrar
+  // una librería de CBOR entera para escribir 77 bytes de forma fija.
+  return concat(
+    new Uint8Array([0xa5]),                    // map(5)
+    new Uint8Array([0x01, 0x02]),              // 1 (kty): 2 (EC2)
+    new Uint8Array([0x03, 0x26]),              // 3 (alg): -7 (ES256)
+    new Uint8Array([0x20, 0x01]),              // -1 (crv): 1 (P-256)
+    new Uint8Array([0x21, 0x58, 0x20]), x,     // -2 (x): bytes(32)
+    new Uint8Array([0x22, 0x58, 0x20]), y,     // -3 (y): bytes(32)
+  )
+}
+
+/** `attestedCredentialData`: aaguid + size + id + la pública en COSE. */
+export function attestedCredentialData (credentialId, coseKey) {
+  const size = new Uint8Array(2)
+  new DataView(size.buffer).setUint16(0, credentialId.length, false)
+  return concat(AAGUID, size, credentialId, coseKey)
+}
+
+/**
+ * Crea una passkey para un sitio. Devuelve lo que se guarda en la bóveda y lo que hay
+ * que devolverle a la página.
+ */
+export async function createCredential ({ rpId, userHandle, userName = '', origin, challenge }) {
+  const pair = await subtle().generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+  const jwkPriv = await subtle().exportKey('jwk', pair.privateKey)
+  const jwkPub = await subtle().exportKey('jwk', pair.publicKey)
+
+  const credentialId = globalThis.crypto.getRandomValues(new Uint8Array(32))
+  const attested = attestedCredentialData(credentialId, coseFromJwk(jwkPub))
+  const authData = await makeAuthenticatorData({
+    rpId,
+    // UV va puesto porque el usuario abre su bóveda para esto: hay verificación real.
+    flags: FLAGS.UP | FLAGS.UV | FLAGS.AT,
+    signCount: 0,
+    attested,
+  })
+
+  const clientDataJSON = enc.encode(JSON.stringify({
+    type: 'webauthn.create',
+    challenge: typeof challenge === 'string' ? challenge : b64urlEncode(challenge),
+    origin,
+    crossOrigin: false,
+  }))
+
+  return {
+    // Lo que se guarda (la privada va cifrada por el modelo, como cualquier secreto).
+    entry: {
+      credentialId: b64urlEncode(credentialId),
+      rpId,
+      userHandle: userHandle ? b64urlEncode(userHandle) : '',
+      userName,
+      privateKey: JSON.stringify(jwkPriv),
+      signCount: 0,
+    },
+    // Lo que se le devuelve a la página, ya en base64url.
+    response: {
+      id: b64urlEncode(credentialId),
+      rawId: b64urlEncode(credentialId),
+      type: 'public-key',
+      response: {
+        clientDataJSON: b64urlEncode(clientDataJSON),
+        // `attestationObject` sin atestación: fmt "none", attStmt vacío.
+        attestationObject: b64urlEncode(concat(
+          new Uint8Array([0xa3]),                                            // map(3)
+          new Uint8Array([0x63]), enc.encode('fmt'),                         // "fmt"
+          new Uint8Array([0x64]), enc.encode('none'),                        // "none"
+          new Uint8Array([0x67]), enc.encode('attStmt'),                     // "attStmt"
+          new Uint8Array([0xa0]),                                            // {}
+          new Uint8Array([0x68]), enc.encode('authData'),                    // "authData"
+          new Uint8Array([0x59]), lengthBytes(authData.length), authData,    // bytes(len)
+        )),
+        publicKeyAlgorithm: -7,
+      },
+    },
+  }
+}
+
+function lengthBytes (n) {
+  const b = new Uint8Array(2)
+  new DataView(b.buffer).setUint16(0, n, false)
+  return b
+}
+
+/**
+ * Firma un reto con una passkey guardada: `sign(authenticatorData || sha256(clientDataJSON))`.
+ * Devuelve también el contador nuevo, que hay que guardar.
+ */
+export async function signAssertion ({ entry, origin, challenge }) {
+  const jwk = JSON.parse(entry.privateKey)
+  const key = await subtle().importKey('jwk', jwk, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign'])
+
+  const signCount = (entry.signCount || 0) + 1
+  const authData = await makeAuthenticatorData({
+    rpId: entry.rpId,
+    flags: FLAGS.UP | FLAGS.UV,
+    signCount,
+  })
+
+  const clientDataJSON = enc.encode(JSON.stringify({
+    type: 'webauthn.get',
+    challenge: typeof challenge === 'string' ? challenge : b64urlEncode(challenge),
+    origin,
+    crossOrigin: false,
+  }))
+
+  const signed = concat(authData, await sha256(clientDataJSON))
+  const raw = new Uint8Array(await subtle().sign(
+    { name: 'ECDSA', hash: 'SHA-256' }, key, signed))
+
+  return {
+    signCount,
+    response: {
+      id: entry.credentialId,
+      rawId: entry.credentialId,
+      type: 'public-key',
+      response: {
+        authenticatorData: b64urlEncode(authData),
+        clientDataJSON: b64urlEncode(clientDataJSON),
+        // WebAuthn pide la firma en DER, no en el crudo de WebCrypto.
+        signature: b64urlEncode(rawSignatureToDer(raw)),
+        userHandle: entry.userHandle || null,
+      },
+    },
+  }
+}
+
+/**
+ * WebCrypto firma ECDSA como `r || s` de 32 bytes cada uno; WebAuthn espera DER
+ * (SEQUENCE de dos INTEGER). Sin esta conversión el servidor rechaza la firma sin
+ * decir por qué, que es de los fallos más caros de diagnosticar.
+ */
+export function rawSignatureToDer (raw) {
+  const r = derInteger(raw.slice(0, 32))
+  const s = derInteger(raw.slice(32, 64))
+  return concat(new Uint8Array([0x30, r.length + s.length]), r, s)
+}
+
+function derInteger (bytes) {
+  let i = 0
+  while (i < bytes.length - 1 && bytes[i] === 0) i++   // sin ceros a la izquierda
+  let v = bytes.slice(i)
+  if (v[0] & 0x80) v = concat(new Uint8Array([0]), v)  // positivo: byte de relleno
+  return concat(new Uint8Array([0x02, v.length]), v)
+}
+
+/** ¿Sirve esta passkey para el sitio que la pide? */
+export function credentialMatches (entry, rpId, allowCredentials) {
+  if (!entry?.webauthn) return false
+  if (entry.webauthn.rpId !== rpId) return false
+  if (!allowCredentials?.length) return true
+  return allowCredentials.some(c => {
+    const id = typeof c.id === 'string' ? c.id : b64urlEncode(c.id)
+    return id === entry.webauthn.credentialId
+  })
+}

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.32.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.js).
+Copia vendorizada de @dotrino/proxy-client@0.32.2 (dotrino-proxy-client/src/{canonical,client,encpub,index,sealing,signature,stats-log,stats,webrtc}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/proxy-client/client.js

@@ -67,6 +67,12 @@ export class WebSocketProxyClient {
     this.autoReconnect = options.autoReconnect !== false
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5
     this.reconnectDelay = options.reconnectDelay ?? 3000
+    // UN SOCKET QUE NO ABRE NI FALLA. El WebSocket de Node (y el del navegador) no tiene
+    // tope para el saludo: si el TCP entra y nadie contesta el upgrade, se queda en
+    // CONNECTING sin disparar `open`, `error` ni `close`. Como el siguiente reintento solo
+    // se programa desde esos eventos, la cadena de reconexión se paraba ahí, en silencio.
+    // Se abandona el intento pasado este tiempo y cuenta como un fallo más.
+    this.connectTimeout = options.connectTimeout ?? 15000
     this.enableWebRTC = options.enableWebRTC !== false
     this.iceServers = options.iceServers || null
 
@@ -225,6 +231,8 @@ export class WebSocketProxyClient {
   connect () {
     return new Promise((resolve, reject) => {
       if (this._connected) return resolve(this.token)
+      // Un reintento que estaba esperando su turno sobra: este `connect()` ya abre uno.
+      if (this._reconnectTimer) { clearTimeout(this._reconnectTimer); this._reconnectTimer = null }
       this._connectResolve = resolve
       this._connectReject = reject
       this._open()
@@ -1242,11 +1250,21 @@ export class WebSocketProxyClient {
 
   _open () {
     registerTransport(this)
+    // El intento anterior, si sigue a medio abrir, se suelta: sus eventos tardíos ya se
+    // ignoran (`ws !== this.ws`), pero el socket quedaría abierto sin dueño.
+    const prev = this.ws
+    if (prev && prev.readyState === 0 /* CONNECTING */) {
+      this.ws = null   // antes de cerrarlo: su `close` ya no es de este cliente
+      try { prev.close() } catch (_) {}
+    }
     const ws = new WebSocket(this.url)
     this.ws = ws
+    const openTimer = this.connectTimeout > 0 ? setTimeout(() => this._onConnectTimeout(ws), this.connectTimeout) : null
+    openTimer?.unref?.()
     // `ws !== this.ws` ⇒ es un socket que ya abandonamos (p.ej. por heartbeat
     // muerto). Ignoramos sus eventos tardíos para no disparar reconexiones dobles.
     ws.addEventListener('open', () => {
+      if (openTimer) clearTimeout(openTimer)
       if (ws !== this.ws) return
       this._connected = true
       this._reconnectAttempts = 0
@@ -1269,6 +1287,7 @@ export class WebSocketProxyClient {
       }
     })
     ws.addEventListener('close', (ev) => {
+      if (openTimer) clearTimeout(openTimer)
       if (ws !== this.ws) return
       this._stopHeartbeat()
       const wasConnected = this._connected
@@ -1301,6 +1320,23 @@ export class WebSocketProxyClient {
     })
   }
 
+  // El intento no abrió ni falló a tiempo: se suelta y se trata como un cierre fallido.
+  _onConnectTimeout (ws) {
+    if (ws !== this.ws || this._connected) return
+    this.ws = null   // a partir de acá, los eventos tardíos de `ws` se ignoran
+    try { ws.close() } catch (_) {}
+    const err = errorCon(`could not open the connection to ${this.url} in ${Math.round(this.connectTimeout / 1000)}s`, 'CONNECT_TIMEOUT')
+    this._emit('error', { type: 'connect_timeout', error: err })
+    if (this._connectReject) {
+      this._connectReject(err)
+      this._connectResolve = null
+      this._connectReject = null
+    }
+    // Lo mismo que en `close`: se sigue reintentando solo si esto ya era un reintento. Un
+    // `connect()` inicial que no abre se rechaza y ya.
+    if (this._reconnectAttempts > 0 && this.autoReconnect) this._scheduleReconnect()
+  }
+
   // ---------- heartbeat ----------
 
   _startHeartbeat () {

package/vault/vendor/roadmap/VERSION.txt

@@ -0,0 +1,3 @@
+Copia vendorizada de @dotrino/roadmap@0.4.13 (dotrino-roadmap/src/{index,manifests}.js).
+NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
+El registro de versiones rotas que viaja con cada versión. Importa @dotrino/compat/ranges.

package/vault/vendor/roadmap/index.js

@@ -0,0 +1,108 @@
+/**
+ * @dotrino/roadmap — EL REGISTRO COMÚN, COMO PIEZA DE CONSULTA.
+ *
+ * Los manifiestos de este repo dicen **qué versión va cada producto, qué protocolo habla,
+ * qué rangos necesita de los demás y qué versiones se saben rotas**. Esta librería es la
+ * forma de leerlos: cada producto la importa en vez de abrir el JSON a mano, porque
+ * treinta piezas parseando el mismo archivo a su manera son treinta formas de equivocarse
+ * y ninguna hace ruido cuando se equivoca.
+ *
+ * REPARTO DE TRABAJO, para que no se mezcle:
+ *
+ *   · **`@dotrino/compat`** decide. Es la lógica: declarar, comparar, avisar.
+ *   · **esto** es el registro. Son los datos, y se editan aquí.
+ *
+ * Va como `peerDependency` de `@dotrino/compat` a propósito: un pilar dentro de otro se
+ * cuela anidado a cada consumidor, y ya pasó (`PENDIENTES.md`, «pilar anidado»).
+ *
+ * EL MANIFIESTO ES POLÍTICA DEL CÓDIGO (dueño, 2026-09-04): viaja con la versión que lo
+ * trae. Lo que llega por la red es el **aviso** firmado de `@dotrino/compat/advisory`, que
+ * suma incompatibilidades y no quita ninguna.
+ */
+import { satisfies } from '@dotrino/compat/ranges'
+import { MANIFESTS } from './manifests.js'
+
+/**
+ * NADA DE DISCO, y esto costó un binario que no arrancaba.
+ *
+ * La primera versión leía los JSON con `fileURLToPath(import.meta.url)` calculado AL
+ * IMPORTARSE. En un ejecutable único eso no existe: la bóveda murió al arrancar con «The
+ * "path" argument must be of type string», y en un navegador no habría arrancado nunca.
+ *
+ * Los consumen ~30 PWAs, varios daemons y un binario. Un registro que hay que leer del
+ * disco no sirve para eso, así que los manifiestos van DENTRO del código
+ * (`src/manifests.js`, generado desde `manifests/*.json`).
+ */
+
+/** Los manifiestos que trae esta versión. Hay uno («dotrino») y caben varios. */
+export function manifestNames () {
+  return Object.keys(MANIFESTS).sort()
+}
+
+/**
+ * Un manifiesto por nombre. LANZA si no está: quien pregunta por un registro que no existe
+ * tiene un error, y devolverle un objeto vacío lo convertiría en «todo compatible».
+ */
+export function loadManifest (name = 'dotrino') {
+  const m = Object.hasOwn(MANIFESTS, String(name)) ? MANIFESTS[String(name)] : null
+  if (!m) throw new Error(`roadmap: there is no manifest called "${name}"`)
+  return m
+}
+
+/** Los productos que el registro conoce. */
+export const products = (m) => Object.keys(m?.products || {}).sort()
+
+/** La ficha de un producto, o `null` si el registro no lo conoce. */
+export const productOf = (m, product) => m?.products?.[product] || null
+
+/** La versión que el registro da por vigente. `null` si no lo conoce. */
+export const currentOf = (m, product) => productOf(m, product)?.current || null
+
+/** El rango que `product` necesita de `peer`, o `null` si no exige nada. */
+export function requirementFor (m, product, peer) {
+  const p = productOf(m, product)
+  if (!p) return null
+  return p.requires?.[peer] ?? null
+}
+
+/**
+ * ¿La versión de `peer` cumple lo que `product` necesita?
+ *
+ * Tres respuestas y ninguna es «bueno, adelante»:
+ *   · `true`  — cumple.
+ *   · `false` — no cumple, y `reason` dice qué se esperaba.
+ *   · cuando el registro NO exige nada, cumple: no exigir es una decisión, no una laguna.
+ *
+ * Si el registro no conoce al producto que pregunta, es `false`: preguntar por quien no
+ * está en el registro no puede salir que sí.
+ */
+export function meets (m, { product, peer, version }) {
+  if (!productOf(m, product)) {
+    return { ok: false, reason: `the registry does not know "${product}"` }
+  }
+  const rango = requirementFor(m, product, peer)
+  if (rango == null) return { ok: true, reason: '' }
+  if (satisfies(version, rango)) return { ok: true, reason: '' }
+  return { ok: false, reason: `${product} needs ${peer} ${rango} and this one is ${version}` }
+}
+
+/** La lista de rotas del registro, lista para pasarla a `check` de `@dotrino/compat`. */
+export const brokenOf = (m) => Array.isArray(m?.broken) ? m.broken : []
+
+/** Lo que el administrador enseña: qué versión debería ir cada pieza, según el registro. */
+export function summary (m) {
+  return {
+    manifest: m?.manifest || null,
+    seq: m?.seq ?? null,
+    issued: m?.issued || null,
+    products: products(m).map((p) => ({
+      product: p,
+      current: currentOf(m, p),
+      protocol: productOf(m, p)?.protocol ?? null,
+      requires: productOf(m, p)?.requires || {}
+    })),
+    broken: brokenOf(m)
+  }
+}
+
+export default { manifestNames, loadManifest, products, productOf, currentOf, requirementFor, meets, brokenOf, summary }