aunubaileys 1.0.12 → 1.0.14

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.14 / Baru di 1.0.14
+
+- 💊 **Bad MAC self-heal** — when a contact's E2E session rots (classic after re-pairing: every message from that one contact fails with “Bad MAC” forever), upstream Baileys just retries against the same stale session endlessly. AunuBaileys now counts consecutive decrypt failures per identity; at the 3rd, it **deletes the stale session** (new `signalRepository.deleteSession`) and forces the next retry receipt to carry fresh keys, so the peer re-initiates a clean session — the same reset dance official clients use. A successful decrypt zeroes the counter. Groups are excluded (sender-key class, handled separately).
+
+### 🆕 What's new in 1.0.13 / Baru di 1.0.13
+
+- 📵 **Bundled WhatsApp version corrected** — the previously bundled version `2.3000.1035194821` is now **rejected by WhatsApp's servers** (connection closed with code 405 at login; proven by a field probe on a real VPS deploy — handshake completes, the login node is sent, the server closes 405). The bundled default is now `2.3000.1043857760`, the version the official version endpoint currently reports as accepted — and the same deploy paired successfully with it. If your pairing suddenly fails with a 405 while your network is fine, this was it. Consumers who override `version` in their socket config are unaffected.
+
 ### 🆕 What's new in 1.0.12 / Baru di 1.0.12
 
 - 🔑 **Pairing waits for the socket — and explains itself when it can't.** Field report from a real VPS deploy: `requestPairingCode` threw a bare Boom 428 "Connection Closed" every time, leaving consumers unable to tell an unready socket from a server rejection. Now `requestPairingCode` **waits internally (up to 30s) for the transport to open** before sending the pairing IQ, fails fast if the connection dies while waiting, and **every pairing failure carries the last disconnect reason** (status code + message) instead of the generic text. The 1.0.10 single-flight guard is kept and covers the wait.

package/lib/Defaults/baileys-version.json

@@ -1,3 +1,3 @@
 {
-    "version": [2, 3000, 1035194821]
+    "version": [2, 3000, 1043857760]
 }

package/lib/Signal/libsignal.js

@@ -66,6 +66,10 @@ export function makeLibSignalRepository(auth) {
                 senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
             };
         },
+        async deleteSession(jid) {
+            const addr = jidToSignalProtocolAddress(jid).toString();
+            await auth.keys.set({ session: { [addr]: null } });
+        },
         async injectE2ESession({ jid, session }) {
             const cipher = new libsignal.SessionBuilder(storage, jidToSignalProtocolAddress(jid));
             await cipher.initOutgoing(session);

package/lib/Socket/messages-recv.js

@@ -15,6 +15,12 @@ export const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid } = config;
     const sock = makeMessagesSocket(config);
     const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage } = sock;
+    /** AunuBaileys: consecutive decrypt failures per signal address.
+     * WhatsApp clients heal a rotten (Bad MAC) session by dropping it and
+     * letting the peer re-initiate from the key bundle in our retry receipt;
+     * upstream Baileys retries forever against the same stale session. */
+    const decryptFailCounts = new Map();
+    const DECRYPT_FAIL_SESSION_RESET_LIMIT = 3;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const msgRetryCache = config.msgRetryCounterCache ||
@@ -659,7 +665,26 @@ export const makeMessagesRecvSocket = (config) => {
                                     return;
                                 }
                                 const encNode = getBinaryNodeChild(node, 'enc');
-                                await sendRetryRequest(node, !encNode);
+                                let forceIncludeKeys = !encNode;
+                                if (!isJidGroup(msg.key.remoteJid) && author) {
+                                    try {
+                                        const addr = signalRepository.jidToSignalProtocolAddress(author);
+                                        const fails = (decryptFailCounts.get(addr) || 0) + 1;
+                                        if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
+                                            await signalRepository.deleteSession(author);
+                                            decryptFailCounts.delete(addr);
+                                            forceIncludeKeys = true;
+                                            logger.warn({ author, addr }, 'aunu: deleted stale E2E session after repeated decrypt failures (Bad MAC self-heal); retry receipt carries fresh keys');
+                                        }
+                                        else {
+                                            decryptFailCounts.set(addr, fails);
+                                        }
+                                    }
+                                    catch (healErr) {
+                                        logger.debug({ err: healErr }, 'aunu: session self-heal step failed, continuing with normal retry');
+                                    }
+                                }
+                                await sendRetryRequest(node, forceIncludeKeys);
                                 if (retryRequestDelayMs) {
                                     await delay(retryRequestDelayMs);
                                 }
@@ -670,6 +695,12 @@ export const makeMessagesRecvSocket = (config) => {
                         });
                     }
                     else {
+                        if (author) {
+                            try {
+                                decryptFailCounts.delete(signalRepository.jidToSignalProtocolAddress(author));
+                            }
+                            catch { }
+                        }
                         // no type in the receipt => message delivered
                         let type = undefined;
                         let participant = msg.key.participant;

package/lib/Types/Signal.d.ts

@@ -52,6 +52,8 @@ export type SignalRepository = {
         ciphertext: Uint8Array;
     }>;
     injectE2ESession(opts: E2ESessionOpts): Promise<void>;
+    /** AunuBaileys: delete the stored E2E session for a JID (used by the Bad MAC self-heal). */
+    deleteSession(jid: string): Promise<void>;
     jidToSignalProtocolAddress(jid: string): string;
 };
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",