@yz-social/civildefense.io 4.4.1

package/server/bridge.js

@@ -0,0 +1,397 @@
+const { BigInt } = globalThis; // for linters
+import { WebSocketServer } from 'ws';
+import NodeTurn from 'node-turn';
+import { KERNEL_VERSION, makeNonce } from '@axona/protocol';
+import { appVersion } from '../public/javascripts/versions.js';
+import { BridgeAxonaNode } from './bridge_axona_node.js'; // FIXME
+
+// TODO: Clean up and simplify.
+// TODO: There's some backward compatible cruft that we do not need. Kill it.
+
+export async function bridge({server,
+			log = console.info, logErr = console.error, logDebug = console.log,
+			VERSION = appVersion,
+			MIN_PEER_VERSION = KERNEL_VERSION,  // FIXME
+			HELLO_TIMEOUT_MS = 5e3,
+			     })  {
+
+  const CLOSE_UPGRADE_REQUIRED = 4426;   // mirrors HTTP 426 "Upgrade Required"
+  const externalIp = '99.122.55.96';
+  const internalIp = '192.168.1.145';
+  const turnServer = new NodeTurn({
+    externalIps: [internalIp], //fixme [externalIp],
+    //minPort: 51021, maxPort: 61000, // Avoiding conflicts on the AT&T BRG320 Gateway
+    authMech: 'none',
+    // authMech: 'long-term',
+    // realm: 'yz',
+    // credentials: {dummy: 'junk'},
+    debugLevel: 'debug'//fixme 'info'
+  });
+  turnServer.start();
+
+  const TURN_URLS = `turn:localhost:3478?transport=udp`;
+  function makeTurnCredential(peerId) {
+    //if (!TURN_AUTH_SECRET) return null;
+    // const expiry   = Math.floor(Date.now() / 1000) + TURN_TTL_SECONDS;
+    const username = 'dummy'; //fixme `${expiry}:${peerId}`;
+    const credential = 'junk'; //fixme
+    // const credential = crypto
+    // 	  .createHmac('sha1', TURN_AUTH_SECRET)
+    // 	  .update(username)
+    // 	  .digest('base64');
+    return { urls: TURN_URLS, username, credential/*, ttlSeconds: TURN_TTL_SECONDS*/ };
+  }
+
+  // FIXME
+  function flagDayFloor(version) {
+    return { floor: MIN_PEER_VERSION,   ns: 'kernel' };
+  }
+  /** Three-component numeric semver compare; returns true iff a >= b. */
+  function gteVersion(a, b) {
+    const pa = String(a).split('.').map(n => parseInt(n, 10) || 0);
+    const pb = String(b).split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+      const ai = pa[i] ?? 0, bi = pb[i] ?? 0;
+      if (ai > bi) return true;
+      if (ai < bi) return false;
+    }
+    return true;
+  }
+
+  // BigInt-aware JSON: the Axona wire protocol uses BigInt node IDs
+  // throughout (path[], queried set, fromId, etc.).  Native
+  // JSON.stringify throws on BigInts; we use a replacer that emits
+  // "<digits>n" suffixed strings, mirrored by an inverse reviver on
+  // the receive side.  This is a transitional convention while the
+  // canonical hex-encoding from the wire spec is rolled out across
+  // every field.
+  function bigintReplacer(_key, value) {
+    if (typeof value === 'bigint') return value.toString() + 'n';
+    if (value instanceof Set)      return [...value];
+    return value;
+  }
+
+  function bigintReviver(_key, value) {
+    if (typeof value === 'string' && /^-?\d+n$/.test(value)) {
+      return BigInt(value.slice(0, -1));
+    }
+    return value;
+  }
+
+  // The bridge runs its own AxonaPeer as a server-class highway node.
+  // Its WebSocket transport piggybacks on the existing browser-bridge
+  // WebSocket connections; no node-webrtc dependency.  See
+  // `bridge_axona_node.js` and `ws_transport.js` for the wire shape.
+  const bridgeNode = new BridgeAxonaNode({
+    sendToConn: (connId, msg) => sendTo(connId, msg),
+    isConnOpen: (connId) => connections.has(connId),
+    // axona/4 — close a connection with the Upgrade-Required code when its
+    // peer can't complete the authenticated handshake (e.g. it speaks the
+    // legacy axona/3 hello).  This is the clean, proto-level upgrade
+    // signal: the peer's kernel prints "[axona] UPGRADE REQUIRED …" on a
+    // 4426 close.  (The WS-level version gate can't separate v3 from v4
+    // because the peer app version is already numerically above any kernel
+    // threshold; the proto at the hello layer is the real boundary.)
+    closeConn: (connId, reason) => {
+      const conn = connections.get(connId);
+      if (conn?.ws) { try { conn.ws.close(CLOSE_UPGRADE_REQUIRED, reason); } catch { /* dying */ } }
+    },
+    log: (event, detail) => logDebug(`axona:${event}`, detail),
+  });
+  await bridgeNode.start();
+  log('axona-ready', {
+    nodeId: bridgeNode.identity.id,
+    region: bridgeNode.identity.region.label,
+  });
+
+  /** @type {Map<string, {ws: any, ip: string, since: number, lastSeenAt: number, pings: number, pongs: number, signalsRelayed: number, ua: string}>} */
+  const connections = new Map();
+  function sendTo(peerId, msg) {
+    const conn = connections.get(peerId);
+    if (!conn) return false;
+    try {
+      conn.ws.send(JSON.stringify(msg, bigintReplacer));
+      return true;
+    } catch (err) {
+      logErr('send-failed', { connId: peerId, type: msg.type, err: err.message });
+      return false;
+    }
+  }
+
+  /** Broadcast to every peer except `exceptId` (typically the originator).
+   *  Skips connections that haven't completed the client-hello version
+   *  check — they should never appear in peer-list or get peer-joined
+   *  notifications. */
+  function broadcast(msg, exceptId = null) {
+    let count = 0;
+    for (const [id, conn] of connections) {
+      if (id === exceptId)  continue;
+      if (!conn.admitted)   continue;
+      try {
+	conn.ws.send(JSON.stringify(msg, bigintReplacer));
+	count++;
+      } catch (err) {
+	logErr('broadcast-send-failed', { connId: id, type: msg.type, err: err.message });
+      }
+    }
+    return count;
+  }
+  
+  let connSeq = 0;
+  const wss = new WebSocketServer({server });
+
+  wss.on('connection', (ws, req) => {
+    const id = `c${(++connSeq).toString(36)}`;
+    const ip = req.headers['x-forwarded-for']?.split(',')[0]?.trim()
+          ?? req.socket.remoteAddress
+          ?? 'unknown';
+    const ua = req.headers['user-agent'] ?? '';
+    const since = Date.now();
+
+    // Snapshot the *existing* peer set BEFORE adding the new one — this
+    // is what we'll send back as `peer-list`.  If we registered first,
+    // the new peer would see itself in its own list.
+    const existingPeers = [...connections.keys()];
+
+    const conn = {
+      ws, ip, since,
+      lastSeenAt: since,
+      pings: 0, pongs: 0, signalsRelayed: 0,
+      ua,
+      admitted: false,      // flipped to true after client-hello version check
+      helloTimer: null,
+      peerVersion: null,
+    };
+    connections.set(id, conn);
+
+    log('connect', { connId: id, ip, total: connections.size, ua: ua.slice(0, 80) });
+
+    // 1. Tell the peer the version gate exists *before* we close.  This
+    //    isn't a `welcome` — peer-list / peer-joined / hello are
+    //    deferred until client-hello passes.  The peer side sends
+    //    'client-hello' immediately after open; if nothing arrives
+    //    within HELLO_TIMEOUT_MS, we close with the upgrade-required
+    //    code so old clients trying to ride through get an obvious
+    //    failure mode instead of a silent ghost connection.
+    sendTo(id, {
+      type:           'version-gate',
+      minPeerVersion: MIN_PEER_VERSION,
+      serverT:        Date.now(),
+    });
+
+    conn.helloTimer = setTimeout(() => {
+      if (conn.admitted) return;
+      logErr('client-hello-timeout', { connId: id, ms: HELLO_TIMEOUT_MS });
+      try {
+	ws.close(CLOSE_UPGRADE_REQUIRED,
+		 `client-hello not received within ${HELLO_TIMEOUT_MS}ms; ` +
+		 `min peer v${MIN_PEER_VERSION} required`);
+      } catch {}
+    }, HELLO_TIMEOUT_MS);
+
+    function admitConnection() {
+      clearTimeout(conn.helloTimer);
+      conn.helloTimer = null;
+      conn.admitted = true;
+
+      // 1a. Mint a short-lived TURN credential (2h expiry) bundled
+      //     into welcome so peer JS never sees a long-term secret.
+      const turn = makeTurnCredential(id);
+      // axona/4 — mint a fresh per-connection nonce; it (with the connId)
+      // is the channel-binding value the peer folds into its signed hello,
+      // and we fold into ours.  A hello captured on one connection can't
+      // be replayed onto another.
+      const serverNonce = makeNonce();
+      conn.serverNonce = serverNonce;
+      sendTo(id, {
+	type:          'welcome',
+	connId:        id,
+	serverT:       Date.now(),
+	version:       VERSION,
+	kernelVersion: KERNEL_VERSION,
+	serverNonce,
+	turn,
+      });
+
+      // 2. Tell the new peer about everyone ALREADY admitted.
+      const admittedPeers = [];
+      for (const [otherId, otherConn] of connections) {
+	if (otherId === id) continue;
+	if (!otherConn.admitted) continue;
+	admittedPeers.push(otherId);
+      }
+      sendTo(id, { type: 'peer-list', peers: admittedPeers, serverT: Date.now() });
+
+      // 3. Tell existing admitted peers that someone new arrived.
+      const announcedTo = broadcast(
+	{ type: 'peer-joined', peerId: id, serverT: Date.now() },
+	id,
+      );
+      log('peer-announce', { connId: id, peers: admittedPeers.length, announcedTo });
+
+      // 4. Axona bootstrap-offer.  The peer's BridgeTransport replies
+      //    with an authenticated hello-ack proving its nodeId; that's
+      //    when our bridge node admits this browser into its synaptome.
+      bridgeNode.sendHello(id, serverNonce);
+    }
+
+    ws.on('message', (data, isBinary) => {
+      // Any inbound bytes — even a malformed payload — count as proof
+      // the peer is still alive.  Stamping liveness before parse means
+      // a peer that briefly sends junk doesn't get kicked for being
+      // idle on top of that.
+      conn.lastSeenAt = Date.now();
+
+      if (isBinary) {
+	logDebug('binary-dropped', { connId: id, bytes: data.length });
+	return;
+      }
+      let msg;
+      try {
+	msg = JSON.parse(data.toString(), bigintReviver);
+      } catch (err) {
+	logErr('bad-json', { connId: id, err: err.message });
+	return;
+      }
+
+      // Version gate.  Before client-hello passes, the ONLY message we
+      // accept is client-hello itself.  Everything else (ping, signal,
+      // axona, etc.) is silently dropped so we don't leak state — and
+      // never relay axona-protocol frames from un-validated peers.
+      if (!conn.admitted) {
+	if (msg.type !== 'client-hello') {
+          logDebug('pre-hello-message-dropped', { connId: id, type: msg.type });
+          return;
+	}
+	const peerVersion = typeof msg.version === 'string' ? msg.version : null;
+	conn.peerVersion = peerVersion;
+	if (!peerVersion) {
+          logErr('client-hello-missing-version', { connId: id });
+          try {
+            ws.close(CLOSE_UPGRADE_REQUIRED,
+		     `client-hello must include 'version' (min v${MIN_PEER_VERSION})`);
+          } catch {}
+          return;
+	}
+	// Two-stage gate: the absolute floor (MIN_PEER_VERSION) AND the
+	// namespace-aware flag-day floor for the v2.9.0 envelope (C-2/E-4).
+	// Report whichever bound actually binds (the higher of the two), so
+	// the close reason names the version the client must reach.
+	const { floor, ns } = flagDayFloor(peerVersion);
+	const effectiveMin = gteVersion(floor, MIN_PEER_VERSION) ? floor : MIN_PEER_VERSION;
+	if (!gteVersion(peerVersion, MIN_PEER_VERSION) || !gteVersion(peerVersion, floor)) {
+          logErr('client-hello-too-old', {
+            connId: id, peerVersion, ns, floor, minPeerVersion: MIN_PEER_VERSION, effectiveMin,
+          });
+          try {
+            ws.close(CLOSE_UPGRADE_REQUIRED,
+		     `peer v${peerVersion} below minimum v${effectiveMin} (${ns}); ` +
+		     `reload axona.net / the demo to upgrade`);
+          } catch {}
+          return;
+	}
+	log('client-hello-admitted', {
+          connId: id, peerVersion, ns, floor, minPeerVersion: MIN_PEER_VERSION,
+	});
+	admitConnection();
+	return;
+      }
+
+      switch (msg.type) {
+      case 'ping': {
+        conn.pings++;
+        try {
+          ws.send(JSON.stringify({
+            type:    'pong',
+            t:       msg.t,                // echo client timestamp unchanged
+            serverT: Date.now(),
+          }));
+          conn.pongs++;
+          //fixme logDebug('pong', { connId: id, n: conn.pings });
+        } catch (err) {
+          logErr('pong-send-failed', { connId: id, err: err.message });
+        }
+        break;
+      }
+
+      case 'axona': {
+        // Axona wire frame from the peer.  The transport unpacks
+        // req/res/ntf, dispatches to handlers, and writes the
+        // response back through the same connection.
+        if (msg.payload && typeof msg.payload === 'object') {
+          bridgeNode.handleAxonaFrame(id, msg.payload);
+        }
+        break;
+      }
+
+      case 'signal': {
+        // Relay opaque SDP / ICE between peers.  The bridge does not
+        // inspect `payload` — it only validates that `to` is connected
+        // and rewrites the addressing so the recipient knows who sent it.
+        const to = msg.to;
+        if (typeof to !== 'string') {
+          logErr('signal-missing-to', { connId: id });
+          break;
+        }
+        if (!connections.has(to)) {
+          // Recipient is gone — silently drop.  This is a normal race:
+          // a peer-left event raced past the signaling message.  We
+          // don't surface an error to the sender because the sender
+          // will receive `peer-left` and clean up on its own.
+          logDebug('signal-drop-unknown-to', { connId: id, to });
+          break;
+        }
+        const delivered = sendTo(to, {
+          type:    'signal',
+          from:    id,
+          payload: msg.payload,
+        });
+        if (delivered) {
+          conn.signalsRelayed++;
+          logDebug('signal-relay', { from: id, to, n: conn.signalsRelayed });
+        }
+        break;
+      }
+
+      default:
+        logDebug('unknown-type', { connId: id, type: msg.type });
+      }
+    });
+
+    ws.on('close', (code, reason) => {
+      const lifeS = Math.floor((Date.now() - since) / 1000);
+      if (conn.helloTimer) {
+	clearTimeout(conn.helloTimer);
+	conn.helloTimer = null;
+      }
+      connections.delete(id);
+
+      // Let the embedded Axona node clean up its bindings + reject any
+      // pending requests to this peer.
+      bridgeNode.handleConnClosed(id);
+
+      // Tell everyone remaining that this peer is gone.  They'll tear
+      // down their RTCPeerConnection for this id.
+      const notifiedCount = broadcast(
+	{ type: 'peer-left', peerId: id, serverT: Date.now() },
+	null,   // peer is already removed from the registry
+      );
+
+      log('disconnect', {
+	connId:    id,
+	code,
+	reason:    reason?.toString() ?? '',
+	lifeS,
+	pings:     conn.pings,
+	pongs:     conn.pongs,
+	signals:   conn.signalsRelayed,
+	notified:  notifiedCount,
+	remaining: connections.size,
+      });
+    });
+
+    ws.on('error', (err) => {
+      logErr('ws-error', { connId: id, err: err.message });
+    });
+  });
+}

package/server/dirname.js

@@ -0,0 +1,15 @@
+/*
+  import() resolves against the directory that contains the import.
+  But NodeJS fs operations resolve against the current working directory from which node was invoked.
+  That wasn't terribly inconvenient when require() was used, because it defined __dirname.
+  Here we export __dirname and resolve().
+  REQUIRES: that this file be imported from this directory.
+*/
+import path from 'node:path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+export const __dirname = path.dirname(__filename); // Only meaningful if loaded from same directory as this file.
+export function resolve(relativePathname) {
+  return path.resolve(__dirname, relativePathname);
+}

package/server/getLocation.js

@@ -0,0 +1,18 @@
+/*
+  Exports the current estimated location, based on IP address.
+  The value is cached in location.json, which can also be hand-edited, cleared, etc.
+ */
+import fs from 'fs/promises';
+import { resolve } from './dirname.js';
+const filename = './location.json';
+export const data = await import(filename, {with: { type: 'json' }})
+  .catch(async () => {
+    const response = await fetch('https://ipinfo.io/json');
+    const string = await response.text();
+    console.log('Estimating location as', string);
+    await fs.writeFile(resolve(filename), string, 'utf8');
+    return {default: JSON.parse(string)};
+  });
+export const [lat, lng] = data.default.loc.split(',').map(parseFloat);
+export const location = {lat, lng};
+

package/server/identity.js

@@ -0,0 +1,111 @@
+// =====================================================================
+// identity.js — bridge's hybrid (legacy 64-bit + kernel 264-bit) identity.
+//
+// v0.3 (kernel 3.0.0): migrated to the kernel's createNodeIdentity (the
+// connection/node identity factory; deriveIdentity was renamed) so the
+// bridge is a kernel-conformant peer in the v1.0 wire protocol — signed
+// envelopes work, peer topics derive correctly under the structured
+// { region, name } addressing model.
+//
+// Returned shape (matches axona-peer/src/identity.js after #46):
+//
+//   Legacy (preserved for ws_transport / bridge_axona_node — they
+//   carry BigInt nodeIds in the hello/hello-ack envelopes that
+//   peer browsers still parse via hexToId)
+//     id        — BigInt 64-bit, top 64 bits of kernel hex id.
+//                 Same S2 prefix at the top (preserves geographic
+//                 routing locality); bottom 56 bits deterministic
+//                 from sha256(pubkey).
+//     geoBits   — 8
+//     region    — { lat, lng, label, id: 'bridge' }
+//     createdAt — ms
+//
+//   Kernel (new)
+//     idHex      — 66-char hex (kernel's full 264-bit nodeId)
+//     pubkey     — Uint8Array (Ed25519)
+//     privateKey — Web Crypto Ed25519 CryptoKey
+//     pubkeyHex  — 64-char hex
+//
+// Persistence: NONE (Phase 2). The bridge transport id is EPHEMERAL — a fresh
+// kernel identity is derived on every start; nothing is written to disk. The
+// bridge directory dedups + ranks on the bridge URL (not the signer), so a
+// rotating signer just re-publishes the same-URL directory entry on restart;
+// clients still discover, rank, and fail over to it. No bridge-identity.json,
+// no BRIDGE_IDENTITY_PATH.
+// =====================================================================
+
+import { createNodeIdentity as kernelCreateNodeIdentity } from '@axona/protocol';
+
+const GEO_BITS = 8;
+
+const DEFAULT_LAT = 37.5;
+const DEFAULT_LNG = -122.3;
+
+function regionFromEnv() {
+  const lat = parseFloat(process.env.BRIDGE_LAT ?? DEFAULT_LAT);
+  const lng = parseFloat(process.env.BRIDGE_LNG ?? DEFAULT_LNG);
+  const label = process.env.BRIDGE_REGION_LABEL
+    ?? `bridge (${lat.toFixed(2)}, ${lng.toFixed(2)})`;
+  return { lat, lng, label, id: 'bridge' };
+}
+
+/**
+ * @typedef {Object} BridgeIdentity
+ * @property {bigint}     id          legacy 64-bit BigInt (top 64 bits of kernel hex)
+ * @property {number}     geoBits     8
+ * @property {Object}     region      { lat, lng, label, id }
+ * @property {number}     createdAt   ms
+ * @property {string}     idHex       kernel 66-char hex node ID
+ * @property {Uint8Array} pubkey
+ * @property {CryptoKey}  privateKey
+ * @property {string}     pubkeyHex
+ */
+
+/**
+ * Derive a fresh node/connection identity.  ASYNC — kernel
+ * createNodeIdentity uses Web Crypto Ed25519 keygen (async).
+ *
+ * @returns {Promise<BridgeIdentity>}
+ */
+export async function loadOrDeriveIdentity() {
+  // Phase 2: the bridge transport id is EPHEMERAL — never persisted. The bridge
+  // mints a fresh kernel node identity on every start (no bridge-identity.json).
+  // The bridge directory + first-party reputation are keyed on the bridge URL,
+  // not on the (now-rotating) signer, so clients still find + rank it across
+  // restarts; a fresh signer simply re-publishes the same-URL directory entry.
+  const labels = regionFromEnv();
+  const kernel = await kernelCreateNodeIdentity({ lat: labels.lat, lng: labels.lng });
+  return buildHybrid(kernel, labels);
+}
+
+/** Build the hybrid identity object from a kernel identity. */
+function buildHybrid(kernel, regionLabels) {
+  // v1.1: full-width 264-bit node ID — same address space as
+  // topic IDs so K-closest XOR distance is meaningful (top 8 bits
+  // = S2 region prefix on both peer IDs and topic IDs).  Replaces
+  // the previous .slice(0, 16) which left the bridge in a 64-bit
+  // mesh while topics were 264-bit.
+  const idBig = BigInt('0x' + kernel.id);
+  return {
+    // Legacy field name; value is now 264-bit BigInt.
+    id:         idBig,
+    geoBits:    GEO_BITS,
+    region:     {
+      lat:   kernel.region.lat,
+      lng:   kernel.region.lng,
+      label: regionLabels.label ?? `bridge (${kernel.region.lat.toFixed(2)}, ${kernel.region.lng.toFixed(2)})`,
+      id:    regionLabels.id    ?? 'bridge',
+    },
+    createdAt:  kernel.createdAt,
+    // Kernel
+    idHex:      kernel.id,
+    pubkey:     kernel.pubkey,
+    privateKey: kernel.privateKey,
+    pubkeyHex:  kernel.pubkeyHex,
+  };
+}
+
+/** Format a 264-bit BigInt nodeId as a 66-char hex string (v1.1 wire
+ *  convention: top 8 bits = S2 region prefix, rest = pubkey-derived
+ *  hash; same width as topic IDs). */
+export function idToHex(id) { return id.toString(16).padStart(66, '0'); }

package/server/location.json

@@ -0,0 +1,12 @@
+{
+  "ip": "99.122.55.96",
+  "hostname": "99-122-55-96.lightspeed.sntcca.sbcglobal.net",
+  "city": "Redwood City",
+  "region": "California",
+  "country": "US",
+  "loc": "37.4852,-122.2364",
+  "org": "AS7018 AT&T Enterprises, LLC",
+  "postal": "94061",
+  "timezone": "America/Los_Angeles",
+  "readme": "https://ipinfo.io/missingauth"
+}