@decentnetwork/peer 0.1.99 → 0.1.100

package/dist/peer.js

@@ -1893,10 +1893,33 @@ export class Peer {
                 // breaker" churned because it accepted new keys with NO such evidence).
                 const peerReKeyed = state.undecryptableRecvMs !== undefined &&
                     state.undecryptableRecvMs > (state.lastPingRecvMs ?? 0);
-                if (sinceEstablished > 1000 && currentSessionAlive && !peerReKeyed) {
-                    this.#debugVerboseLog(`hs_recv ignored friend=${friendId} (new session pubkey on live established session, ${sinceEstablished}ms after establish)`);
+                const now = Date.now();
+                const sameRehsKey = state.rehsSessionPublicKey !== undefined &&
+                    bytesEqual(state.rehsSessionPublicKey, hs.sessionPublicKey);
+                const rehsWindowExpired = state.rehsLastMs === undefined ||
+                    now - state.rehsLastMs > REHS_WINDOW_MS;
+                if (!sameRehsKey || rehsWindowExpired) {
+                    state.rehsSessionPublicKey = hs.sessionPublicKey.slice();
+                    state.rehsCount = 1;
+                    state.rehsFirstMs = now;
+                }
+                else {
+                    state.rehsCount = (state.rehsCount ?? 0) + 1;
+                }
+                state.rehsLastMs = now;
+                const rehsElapsed = now - (state.rehsFirstMs ?? now);
+                const persistentRehs = (state.rehsCount ?? 0) >= REHS_ACCEPT_COUNT &&
+                    rehsElapsed >= REHS_ACCEPT_MS &&
+                    rehsElapsed <= REHS_WINDOW_MS;
+                if (sinceEstablished > 1000 && currentSessionAlive && !peerReKeyed && !persistentRehs) {
+                    this.#debugVerboseLog(`hs_recv ignored friend=${friendId} (new session pubkey on live established session, ` +
+                        `${sinceEstablished}ms after establish, attempts=${state.rehsCount ?? 0})`);
                     return;
                 }
+                if (persistentRehs) {
+                    this.#debugLog(`hs_recv accepting persistent re-handshake friend=${friendId} ` +
+                        `(attempts=${state.rehsCount}, elapsed=${rehsElapsed}ms)`);
+                }
                 if (peerReKeyed) {
                     this.#debugLog(`hs_recv accepting re-handshake friend=${friendId} (peer re-keyed: undecryptable data since last good packet)`);
                 }
@@ -1908,6 +1931,10 @@ export class Peer {
             state.sessionSharedKey = nacl.box.before(hs.sessionPublicKey, state.ourSessionKeyPair.secretKey);
             state.established = true;
             state.sessionEstablishedAtMs = Date.now();
+            state.rehsCount = undefined;
+            state.rehsFirstMs = undefined;
+            state.rehsLastMs = undefined;
+            state.rehsSessionPublicKey = undefined;
             // Fresh session up — reset the higher-pubkey defer window for the
             // next outage (see #initiateSession).
             this.#initiateDeferSinceMs.delete(friendId);
@@ -1936,7 +1963,13 @@ export class Peer {
                 state.sendPacketNumber ??= 0;
                 state.receiveBufferStart ??= 0;
             }
-            state.lastPingRecvMs = Date.now();
+            // A handshake authenticates identities and proposes keys, but it does not
+            // prove that CRYPTO_DATA encrypted under those keys works in both
+            // directions. Keep a fresh session "unproven" until the first packet is
+            // actually decrypted; otherwise a half-open session receives the 180s
+            // proven-session blackout grace instead of the 32s recovery deadline.
+            if (isNewSession)
+                state.lastPingRecvMs = undefined;
             state.pendingEcho = undefined;
             state.pendingCookiePeerDhtPublicKey = undefined;
             this.#debugLog(`hs_recv friend=${friendId} initiated=${weInitiated ? 1 : 0} remote=${remote.address}:${remote.port}`);
@@ -2084,6 +2117,13 @@ export class Peer {
                 // stays unset → udpFresh false → bulk data (files) never ride the LAN
                 // even when LAN UDP is flowing both ways (the snoopy slow-file bug).
                 state.lastPingRecvMs = Date.now();
+                // Any successfully decrypted packet proves the current session is
+                // healthy. Forget rejected new-key proposals so late/replayed
+                // handshakes can never accumulate across healthy traffic.
+                state.rehsCount = undefined;
+                state.rehsFirstMs = undefined;
+                state.rehsLastMs = undefined;
+                state.rehsSessionPublicKey = undefined;
                 if (this.#remoteIsTcp(remote)) {
                     state.hasTcpRoute = true;
                 }
@@ -2932,6 +2972,18 @@ export class Peer {
                 // sessions a long grace so a blackout doesn't churn them via re-handshake;
                 // unproven sessions still time out fast to self-heal a wedged handshake.
                 const proven = session.lastPingRecvMs !== undefined;
+                // A proven session normally gets a long blackout grace: if the network
+                // disappears, keeping the known-good keys avoids unnecessary churn.
+                // A restarted peer is different. Once our last good decrypt goes quiet
+                // while fresh packets from that same friend keep failing authentication,
+                // the transport is alive but the keys are not. Waiting the full proven
+                // timeout turns every peer restart into a multi-minute wedge. Require a
+                // sustained good-packet silence plus recent desync evidence so a single
+                // late relay duplicate can never tear down a healthy session.
+                const recentUndecryptable = session.undecryptableRecvMs !== undefined &&
+                    session.undecryptableRecvMs > lastAlive &&
+                    now - session.undecryptableRecvMs <= REINIT_STUCK_MS;
+                const rekeyStuck = recentUndecryptable && silentFor > REINIT_ON_DESYNC_MS;
                 // A relay-only session (synthetic tcp: remote, no UDP path) whose
                 // relay route is gone has NO transport at all — nothing can arrive
                 // and nothing we send leaves. The proven-session blackout grace
@@ -2942,7 +2994,23 @@ export class Peer {
                 const relayOnly = !session.remote || session.remote.host.startsWith("tcp:");
                 const pathless = relayOnly && !session.hasTcpRoute;
                 const deadline = proven && !pathless ? PROVEN_SESSION_HARD_TIMEOUT_MS : FRIEND_TIMEOUT_MS;
-                if (proven && !pathless && silentFor > FRIEND_TIMEOUT_MS && silentFor <= deadline) {
+                if (rekeyStuck) {
+                    this.#debugLog(`session re-key desync for ${friendId} (no good decrypt in ${silentFor}ms; ` +
+                        `undecryptable packets still arriving) — tearing down to re-handshake`);
+                    this.#friendSessions.delete(friendId);
+                    this.#setFriendOffline(friendId);
+                    try {
+                        const pk = base58ToBytes(friend.pubkey);
+                        if (pk.length === 32)
+                            this.#tcpRelays?.requestRoute(pk);
+                        const dhtPk = this.#friendDhtKeys.get(friendId);
+                        if (dhtPk && dhtPk.length === 32)
+                            this.#tcpRelays?.requestRoute(dhtPk);
+                    }
+                    catch { /* skip malformed */ }
+                    continue;
+                }
+                else if (proven && !pathless && silentFor > FRIEND_TIMEOUT_MS && silentFor <= deadline) {
                     // Blackout grace: keep the proven session and keep probing (the
                     // keepalive + UDP re-punch + relay-keepalive below all still run). Do
                     // NOT delete or re-handshake — that's what desyncs and churns. The peer,

package/package.json

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