@decentnetwork/peer 0.1.151 → 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.d.ts

@@ -80,13 +80,31 @@ export declare class Peer {
     };
     addKnownNodes(nodes: NetworkNode[]): void;
     knownNodes(): NetworkNode[];
-    sendFriendRequest(pubkey: string, hello?: string): Promise<void>;
+    /** @param opts.force  Send even when this friend looks already-accepted.
+     *
+     *  The idempotency guard below is right for automatic retries and wrong for
+     *  a person clicking "add". If the other side REJECTED an earlier request,
+     *  their app forgets it — but a net_crypto session may already have been
+     *  established, so this side keeps acceptedAt and skips every later attempt.
+     *  Neither peer is then in the other's friend list and nothing either user
+     *  does can fix it: every add is silently dropped here. A deliberate add has
+     *  to be able to say "I mean it". */
+    sendFriendRequest(pubkey: string, hello?: string, opts?: {
+        force?: boolean;
+    }): Promise<void>;
     lastFriendRequestDispatch(): {
         transport: "onion" | "direct";
         routes: number;
         targets: number;
     } | undefined;
     acceptFriendRequest(pubkey: string): Promise<void>;
+    /** Decline an inbound request.
+     *
+     *  Also drops any friend record and session the request already created.
+     *  Clearing only the pending list left the transport half-attached: the
+     *  sender saw a session, marked us accepted, and its idempotency guard then
+     *  skipped every later attempt — so a rejected peer could never ask again,
+     *  and neither side could see why. */
     rejectFriendRequest(pubkey: string): void;
     /**
      * Drop a friend entirely: tear down any active net_crypto session, forget

package/dist/peer.js

@@ -1040,7 +1040,16 @@ export class Peer {
     knownNodes() {
         return [...this.#knownNodes];
     }
-    async sendFriendRequest(pubkey, hello) {
+    /** @param opts.force  Send even when this friend looks already-accepted.
+     *
+     *  The idempotency guard below is right for automatic retries and wrong for
+     *  a person clicking "add". If the other side REJECTED an earlier request,
+     *  their app forgets it — but a net_crypto session may already have been
+     *  established, so this side keeps acceptedAt and skips every later attempt.
+     *  Neither peer is then in the other's friend list and nothing either user
+     *  does can fix it: every add is silently dropped here. A deliberate add has
+     *  to be able to say "I mean it". */
+    async sendFriendRequest(pubkey, hello, opts) {
         if (!this.#keyPair || !this.#announceDataKey) {
             throw new Error("Peer is not started");
         }
@@ -1056,7 +1065,7 @@ export class Peer {
         const friendAddress = parseCarrierAddress(pubkey);
         const friendId = carrierIdFromPublicKey(friendAddress.publicKey);
         const existing = this.#friends.get(friendId);
-        if (existing?.acceptedAt) {
+        if (existing?.acceptedAt && !opts?.force) {
             this.#debugLog(`friend request skipped — ${friendId} already accepted at ${new Date(existing.acceptedAt).toISOString()}`);
             this.#lastFriendRequestDispatch = {
                 transport: "onion",
@@ -1237,8 +1246,17 @@ export class Peer {
             this.#debugLog(`accept friend: initiate session failed for ${pubkey}: ${error.message}`);
         });
     }
+    /** Decline an inbound request.
+     *
+     *  Also drops any friend record and session the request already created.
+     *  Clearing only the pending list left the transport half-attached: the
+     *  sender saw a session, marked us accepted, and its idempotency guard then
+     *  skipped every later attempt — so a rejected peer could never ask again,
+     *  and neither side could see why. */
     rejectFriendRequest(pubkey) {
         this.#pendingFriendRequests.delete(pubkey);
+        if (this.#friends.has(pubkey))
+            this.removeFriend(pubkey);
     }
     /**
      * Drop a friend entirely: tear down any active net_crypto session, forget
@@ -6942,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
@@ -6953,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.151",
+  "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",