@decentnetwork/peer 0.1.152 → 0.1.154

package/dist/compat/express.js

@@ -2,6 +2,7 @@ import { ByteBuffer, Encoding } from "flatbuffers";
 import nacl from "tweetnacl";
 import { base58ToBytes, bytesToBase58 } from "../utils/base58.js";
 import { randomBytes } from "../utils/bytes.js";
+import { sharedKey as sharedKeyFor } from "../crypto/shared-key.js";
 const EXPRESS_MAGIC = 0xca6ee595;
 const NONCE_SIZE = 24;
 const HTTP_TIMEOUT_MS = 15000;
@@ -34,7 +35,7 @@ export class LegacyExpressClient {
                 host: node.host,
                 port: node.port,
                 tls: node.tls !== false, // default HTTPS; opt into HTTP with tls:false
-                sharedKey: nacl.box.before(expressPk, this.#selfKeyPair.secretKey)
+                sharedKey: sharedKeyFor(expressPk, this.#selfKeyPair.secretKey)
             };
         });
     }
@@ -49,7 +50,7 @@ export class LegacyExpressClient {
         if (friendPk.length !== 32) {
             throw new Error("friend user id must decode to 32-byte public key");
         }
-        const friendSharedKey = nacl.box.before(friendPk, this.#selfKeyPair.secretKey);
+        const friendSharedKey = sharedKeyFor(friendPk, this.#selfKeyPair.secretKey);
         const friendEncrypted = encrypt(friendSharedKey, carrierPacket);
         await this.#postEncrypted(friendUserId, friendEncrypted);
     }
@@ -112,7 +113,7 @@ export class LegacyExpressClient {
                         if (friendPk.length !== 32) {
                             continue;
                         }
-                        const friendSharedKey = nacl.box.before(friendPk, this.#selfKeyPair.secretKey);
+                        const friendSharedKey = sharedKeyFor(friendPk, this.#selfKeyPair.secretKey);
                         const packet = decrypt(friendSharedKey, msg.payload);
                         if (!packet) {
                             continue;

package/dist/compat/net-crypto.js

@@ -1,6 +1,7 @@
 import nacl from "tweetnacl";
 import { createHash } from "node:crypto";
 import { concatBytes, randomBytes } from "../utils/bytes.js";
+import { sharedKey as sharedKeyFor } from "../crypto/shared-key.js";
 export const NET_PACKET_COOKIE_REQUEST = 0x18;
 export const NET_PACKET_COOKIE_RESPONSE = 0x19;
 export const NET_PACKET_CRYPTO_HS = 0x1a;
@@ -44,7 +45,7 @@ export function createCookieRequest(opts) {
         throw new Error("cookie request plaintext size mismatch");
     }
     const nonce = randomBytes(NONCE_SIZE);
-    const sharedKey = nacl.box.before(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
+    const sharedKey = sharedKeyFor(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
     const cipher = nacl.secretbox(plain, nonce, sharedKey);
     return concatBytes([
         Uint8Array.of(NET_PACKET_COOKIE_REQUEST),
@@ -60,7 +61,7 @@ export function openCookieRequest(packet, opts) {
     const senderDhtPublicKey = packet.slice(1, 1 + KEY_SIZE);
     const nonce = packet.slice(1 + KEY_SIZE, 1 + KEY_SIZE + NONCE_SIZE);
     const cipher = packet.slice(1 + KEY_SIZE + NONCE_SIZE);
-    const sharedKey = nacl.box.before(senderDhtPublicKey, opts.receiverDhtSecretKey);
+    const sharedKey = sharedKeyFor(senderDhtPublicKey, opts.receiverDhtSecretKey);
     const plain = nacl.secretbox.open(cipher, nonce, sharedKey);
     if (!plain || plain.length !== COOKIE_REQUEST_PLAIN_LENGTH) {
         return undefined;
@@ -79,7 +80,7 @@ export function createCookieResponse(opts) {
     });
     const plain = concatBytes([cookie, writeUint64Le(opts.request.echo)]);
     const nonce = randomBytes(NONCE_SIZE);
-    const sharedKey = nacl.box.before(opts.request.senderDhtPublicKey, opts.receiverDhtSecretKey);
+    const sharedKey = sharedKeyFor(opts.request.senderDhtPublicKey, opts.receiverDhtSecretKey);
     const cipher = nacl.secretbox(plain, nonce, sharedKey);
     return concatBytes([Uint8Array.of(NET_PACKET_COOKIE_RESPONSE), nonce, cipher]);
 }
@@ -89,7 +90,7 @@ export function openCookieResponse(packet, opts) {
     }
     const nonce = packet.slice(1, 1 + NONCE_SIZE);
     const cipher = packet.slice(1 + NONCE_SIZE);
-    const sharedKey = nacl.box.before(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
+    const sharedKey = sharedKeyFor(opts.receiverDhtPublicKey, opts.senderDhtSecretKey);
     const plain = nacl.secretbox.open(cipher, nonce, sharedKey);
     if (!plain || plain.length !== COOKIE_RESPONSE_PLAIN_LENGTH) {
         return undefined;
@@ -135,7 +136,7 @@ export function createCryptoHandshake(opts) {
         sha512(opts.recipientCookie),
         ownCookie
     ]);
-    const sharedKey = nacl.box.before(opts.receiverRealPublicKey, opts.senderRealSecretKey);
+    const sharedKey = sharedKeyFor(opts.receiverRealPublicKey, opts.senderRealSecretKey);
     const innerCipher = nacl.secretbox(innerPlain, innerNonce, sharedKey);
     return concatBytes([Uint8Array.of(NET_PACKET_CRYPTO_HS), opts.recipientCookie, innerNonce, innerCipher]);
 }
@@ -152,7 +153,7 @@ export function openCryptoHandshake(packet, opts) {
     const senderDhtPublicKey = cookieParsed.dhtPublicKey;
     const nonce = packet.slice(1 + COOKIE_LENGTH, 1 + COOKIE_LENGTH + NONCE_SIZE);
     const cipher = packet.slice(1 + COOKIE_LENGTH + NONCE_SIZE);
-    const sharedKey = nacl.box.before(senderRealPublicKey, opts.receiverRealSecretKey);
+    const sharedKey = sharedKeyFor(senderRealPublicKey, opts.receiverRealSecretKey);
     const inner = nacl.secretbox.open(cipher, nonce, sharedKey);
     if (!inner || inner.length !== HANDSHAKE_INNER_LENGTH) {
         return undefined;

package/dist/crypto/shared-key.d.ts

@@ -0,0 +1,4 @@
+export declare function sharedKey(theirPublicKey: Uint8Array, ourSecretKey: Uint8Array): Uint8Array;
+/** Drop everything — for tests, and for a key rotation that reuses the same
+ *  Uint8Array instance. */
+export declare function clearSharedKeyCache(): void;

package/dist/crypto/shared-key.js

@@ -0,0 +1,45 @@
+import nacl from "tweetnacl";
+import { bytesToHex } from "../utils/bytes.js";
+/**
+ * X25519 shared-secret derivation, memoised.
+ *
+ * `nacl.box.before(theirPk, ourSk)` is a scalar multiplication — the single
+ * most expensive thing tweetnacl does, and it is pure JS. Every packet that
+ * derived its key inline paid for one.
+ *
+ * That cost is invisible until a node has friends. Measured with a 53-friend
+ * list against a peer that could reach none of them (the ordinary case: a
+ * laptop whose friends are asleep), the connection loop's cookie requests put
+ *
+ *   60.8%  tweetnacl M            (bignum multiply)
+ *   11.4%  crypto_scalarmult
+ *
+ * of the process on one function — 72% of the CPU, for keys that never change.
+ * A browser tab showed the same shape at 100% of a core for 25 hours.
+ *
+ * The result depends only on (theirPk, ourSk), so it is cached. Keyed on the
+ * public key, with the secret compared by IDENTITY rather than content: a peer
+ * passes the same Uint8Array every time, and a different keypair recomputes
+ * rather than risking a stale hit. Nothing secret is used as a map key.
+ */
+const cache = new Map();
+const MAX_ENTRIES = 1024;
+export function sharedKey(theirPublicKey, ourSecretKey) {
+    const id = bytesToHex(theirPublicKey);
+    const hit = cache.get(id);
+    if (hit && hit.sk === ourSecretKey)
+        return hit.key;
+    const key = nacl.box.before(theirPublicKey, ourSecretKey);
+    if (cache.size >= MAX_ENTRIES) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+            cache.delete(oldest);
+    }
+    cache.set(id, { sk: ourSecretKey, key });
+    return key;
+}
+/** Drop everything — for tests, and for a key rotation that reuses the same
+ *  Uint8Array instance. */
+export function clearSharedKeyCache() {
+    cache.clear();
+}

package/dist/peer.js

@@ -6960,7 +6960,41 @@ export class Peer {
         const wrapped = concatBytes([Uint8Array.of(0x69, 0x76, 0x65, 0x67), packet]);
         await this.#udp.send(Buffer.from(wrapped), node.host, node.port);
     }
+    /** Hand an onion request to the connected relays, which stand in for hop A. */
+    #sendOnionOverRelays(nodeB, nodeC, nodeD, payloadForNodeD) {
+        if (!this.#tcpRelays || this.#tcpRelays.connectedCount() === 0)
+            return;
+        try {
+            const tcpPacket = createOnionRequest0Tcp({
+                nodeBHost: nodeB.host,
+                nodeBPort: nodeB.port,
+                nodeBPublicKey: nodeB.publicKey,
+                nodeCHost: nodeC.host,
+                nodeCPort: nodeC.port,
+                nodeCPublicKey: nodeC.publicKey,
+                nodeDHost: nodeD.host,
+                nodeDPort: nodeD.port,
+                payloadForNodeD
+            });
+            const sent = this.#tcpRelays.sendOnionRequest(tcpPacket);
+            if (sent > 0) {
+                this.#diagTcpOnionSent += 1;
+                this.#debugVerboseLog(`tcp onion request sent via ${sent} relay(s) to ${nodeD.host}:${nodeD.port}`);
+            }
+        }
+        catch {
+            /* malformed hop key — nothing to send */
+        }
+    }
     async #sendThroughOnionPath(payloadForNodeD, nodeD, pathOffset = 0, forcedPath) {
+        // Does this host have real UDP? The browser shim binds and drops, and its
+        // socket reports port 0. Building the UDP onion request there is six
+        // scalar multiplications — three ephemeral keypairs and three
+        // Diffie-Hellmans, in pure JS — for a packet that goes nowhere. Measured:
+        // onion construction was 79% of all crypto time, split almost exactly
+        // between the UDP variant and its TCP twin, and a browser tab held a core
+        // at 100% for 25 hours doing it. Decide BEFORE constructing anything.
+        const udpUsable = (this.#udp?.localPort() ?? 0) > 0;
         const path = forcedPath === "direct" ? undefined : forcedPath ?? this.#selectOnionPath(nodeD, pathOffset);
         if (!path) {
             // No 3-hop UDP path. "Direct" then meant a plain UDP send — which on a
@@ -6971,37 +7005,29 @@ export class Peer {
             // A RELAYED onion request needs only two hops: the relay is node A. So
             // try that before giving up, and only fall through to the UDP send when
             // there are no relays or not even two usable hops.
-            if (this.#tcpRelays && this.#tcpRelays.connectedCount() > 0) {
-                const hops = this.#selectTcpOnionHops(nodeD, pathOffset);
-                if (hops) {
-                    try {
-                        const tcpPacket = createOnionRequest0Tcp({
-                            nodeBHost: hops.nodeB.host,
-                            nodeBPort: hops.nodeB.port,
-                            nodeBPublicKey: hops.nodeB.publicKey,
-                            nodeCHost: hops.nodeC.host,
-                            nodeCPort: hops.nodeC.port,
-                            nodeCPublicKey: hops.nodeC.publicKey,
-                            nodeDHost: nodeD.host,
-                            nodeDPort: nodeD.port,
-                            payloadForNodeD
-                        });
-                        const sent = this.#tcpRelays.sendOnionRequest(tcpPacket);
-                        if (sent > 0) {
-                            this.#diagTcpOnionSent += 1;
-                            this.#debugLog(`no 3-hop path for ${nodeD.host}:${nodeD.port} — relayed 2-hop onion via ${sent} relay(s) (B=${hops.nodeB.host} C=${hops.nodeC.host})`);
-                            return "direct";
-                        }
-                    }
-                    catch {
-                        /* malformed hop key — fall through to the UDP attempt */
-                    }
-                }
+            const hops = this.#tcpRelays && this.#tcpRelays.connectedCount() > 0
+                ? this.#selectTcpOnionHops(nodeD, pathOffset)
+                : undefined;
+            if (hops) {
+                this.#sendOnionOverRelays(hops.nodeB, hops.nodeC, nodeD, payloadForNodeD);
+                return "direct";
+            }
+            if (!udpUsable) {
+                // Nothing can carry it: no relay hops and no UDP. Say so instead of
+                // handing the packet to a socket that drops it silently.
+                this.#debugLog(`no route for ${nodeD.host}:${nodeD.port} — no relay hops and no UDP`);
+                return "direct";
             }
             this.#debugLog(`no onion path for ${nodeD.host}:${nodeD.port}, sending direct`);
             await this.#sendPacket(payloadForNodeD, nodeD);
             return "direct";
         }
+        if (!udpUsable) {
+            // No UDP: go straight to the relay form, which is the only one that can
+            // actually leave this host.
+            this.#sendOnionOverRelays(path.nodeB, path.nodeC, nodeD, payloadForNodeD);
+            return path;
+        }
         this.#debugLog(`sending onion initial via ${path.nodeA.node.host}:${path.nodeA.node.port} to ${nodeD.host}:${nodeD.port}`);
         const packet = createOnionRequest0({
             nodeAPublicKey: path.nodeA.publicKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.152",
+  "version": "0.1.154",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",