@decentnetwork/peer 0.1.91 → 0.1.92

package/dist/peer.js

@@ -1725,7 +1725,45 @@ export class Peer {
                 else {
                     this.#adoptRemote(state, remote.address, remote.port);
                 }
-                state.lastPingRecvMs = Date.now();
+                // CONVERGENCE RESYNC: the peer is retransmitting the SAME session pubkey
+                // we already hold, so OUR view of the session looks fine. But if we've
+                // been receiving crypto data from this peer we CANNOT decrypt, the peer
+                // is holding a STALE copy of OUR session pubkey (it re-keyed, or we did,
+                // and our reply handshake never reached it) — it encrypts to a key we no
+                // longer have, so every data packet is "no session matched" and it keeps
+                // retransmitting its handshake forever. Silently preserving deadlocks the
+                // session PERMANENTLY (observed callpass↔mac: 11h, 20k undecryptable, IP
+                // + messages both dead while presence shows "online"). Re-send our reply
+                // handshake so the peer re-derives its shared key against our CURRENT
+                // session pubkey. Rate-limited (peer retransmits ~1/s); a healthy session
+                // never sets undecryptableRecvMs, so this can NEVER churn a working one.
+                const now = Date.now();
+                const peerSendingUndecryptable = state.undecryptableRecvMs !== undefined &&
+                    now - state.undecryptableRecvMs < FRIEND_TIMEOUT_MS;
+                const resyncDue = now - (state.lastResyncHandshakeMs ?? 0) > 2000;
+                if (peerSendingUndecryptable && resyncDue) {
+                    state.lastResyncHandshakeMs = now;
+                    state.lastPingRecvMs = now;
+                    const reply = createCryptoHandshake({
+                        recipientCookie: hs.embeddedCookie,
+                        baseNonce: state.ourBaseNonce,
+                        sessionPublicKey: state.ourSessionKeyPair.publicKey,
+                        senderRealSecretKey: this.#keyPair.secretKey,
+                        senderRealPublicKey: this.#keyPair.publicKey,
+                        senderDhtPublicKey: this.#keyPair.publicKey,
+                        receiverRealPublicKey: hs.senderRealPublicKey,
+                        receiverDhtPublicKey: hs.senderDhtPublicKey,
+                        localCookieSymmetricKey: this.#cookieSymmetricKey
+                    });
+                    const sendResync = () => this.#remoteIsTcp(remote)
+                        ? Promise.resolve(this.#tcpRelays?.sendOobToFriend(hs.senderDhtPublicKey, reply) ?? 0)
+                        : this.#sendPacket(reply, { host: remote.address, port: remote.port });
+                    void sendResync()
+                        .then(() => this.#debugLog(`hs_recv duplicate but peer sent undecryptable data — re-sent our handshake to resync friend=${friendId}`))
+                        .catch((error) => this.#debugLog(`resync handshake failed for ${friendId}: ${error.message}`));
+                    return;
+                }
+                state.lastPingRecvMs = now;
                 this.#debugVerboseLog(`hs_recv duplicate friend=${friendId} remote=${remote.address}:${remote.port} (session preserved)`);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "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",