@aunucore/baileys 1.0.75 → 1.0.77

package/README.md

@@ -128,9 +128,9 @@ Everything else is the upstream core. The patch layer stays small and deliberate
 
 ### 📰 Recent releases
 
+- **1.0.76 — Hunt round 3: the decoder + trust-boundary batch.** Every claim in an external deep-audit was verified against the tree (with repros) before anything was patched. The WABinary decoder gets a 512-level nesting cap (a ~100 KB stanza previously recursed 20,000 deep into a raw stack-overflow RangeError) and a 128 MiB zlib output cap (a max-size frame could inflate ~1000× toward OOM). Media downloads now verify the WhatsApp HMAC on full downloads — tampered or truncated media errors out instead of decrypting silently — and download hosts are allowlisted to WhatsApp/Facebook CDN domains, closing a sender-driven SSRF (foreign hosts fall back to `mmg.whatsapp.net`). Auth files are written `0600` (they hold private keys; old `0644` files self-heal on next save), GraphQL error bodies are drained instead of pinning keep-alive sockets, `link_code_companion_reg` key material is length-validated before any pairing secret is derived, the session watchdog also hears raw WebSocket frames (buffered-event delays no longer read as a false deaf session), and a dead `taskTimeout` in the mutex factory is removed. Deliberately untouched, with recorded reasoning: `isTrustedIdentity` (upstream TOFU), unbounded host store arrays, and the app-state transaction design.
 - **1.0.75 — Partial-config safety + watchdog cleanup.** A partial `transactionOpts` in the socket config can no longer kill every key-store transaction: the config is deep-merged over the defaults and the transaction layer falls back per-field (`maxCommitRetries` 10, `delayBetweenTriesMs` 3000, retries clamped to at least 1 so an explicit `0` means exactly one attempt) — previously the shallow config spread replaced the whole default object, `maxCommitRetries` came out `undefined`, and every transaction threw `failed to commit transaction mutations` without a single commit attempt. The session watchdog's interval is now stopped when the socket ends (its `stop()` existed but was never called anywhere), closing a one-timer-and-socket-graph leak per reconnect cycle.
 - **1.0.74 — Fix-all batch.** The entire 1.0.74 heartbeat queue, closed in one version: `resyncAppState` can no longer spin forever holding the key-store transaction mutex (server-omitted collections finish with a warning, plus a 25-round cap), `startByte`-only media downloads no longer silently return an empty stream, an all-failed sticker pack throws Boom 400 instead of uploading empty, key-material guards now check TYPES (Buffer/string only) at six sites so wrong-typed creds fail descriptively instead of as raw TypeErrors, the noise handshake guards a missing `noiseKey` up front, the pre-login `creds.me` dereference family is closed (acks for `<unavailable>` stanzas survive fresh pairing), and two per-entity maps (`RateLimiter.hits`, bug-guard `recentBySender`) evict stale keys with a lazy sweep.
-- **1.0.73 — Heartbeat queue + a new README.** Three verified heartbeat fixes: a corrupt frame header can no longer wedge `decodeFrame` (zero-length headers are skipped, frames over 10 MiB fail loudly instead of buffering forever), `botRecentSecretsByChat` is capped at 1,000 chats FIFO, and bare key-store writes are serialized through the transaction mutex so a `migrateSession` commit can't overwrite a fresher session record. Plus a fully rewritten README and 46 curated npm keywords.
 Full changelog for every version since 1.0.2: **[docs](https://docsjs.aunucore.eu.cc)** · **[GitHub Releases](https://github.com/AunuCore/AunuBaileys-lib/releases)**.
 
 ### 🙏 Credits

package/lib/Socket/graphql.js

@@ -68,7 +68,12 @@ export const executeWWWGraphQL = async (docId, variables, accessToken, dataPath
         body
     });
     if (!res.ok) {
-        throw new Boom(`GraphQL HTTP error ${res.status}`, { statusCode: res.status });
+        // AunuBaileys (1.0.76): Hunt-ronde-3 — drain the error body before
+        // throwing. An unconsumed fetch body pins its keep-alive socket
+        // out of the undici pool until GC; repeated GraphQL errors would
+        // steadily starve the pool. The body text also improves the error.
+        const errBody = await res.text().catch(() => '');
+        throw new Boom(`GraphQL HTTP error ${res.status}${errBody ? `: ${errBody.slice(0, 200)}` : ''}`, { statusCode: res.status });
     }
     const json = await res.json();
     return parseGraphQLResponse(json, dataPath);
@@ -104,7 +109,9 @@ export const executeWamoGraphQL = async (docId, variables, wamoAuth = {}, dataPa
         body: params.toString()
     });
     if (!res.ok) {
-        throw new Boom(`Wamo GraphQL HTTP error ${res.status}`, { statusCode: res.status });
+        // AunuBaileys (1.0.76): drain the error body (see executeWWWGraphQL).
+        const errBody = await res.text().catch(() => '');
+        throw new Boom(`Wamo GraphQL HTTP error ${res.status}${errBody ? `: ${errBody.slice(0, 200)}` : ''}`, { statusCode: res.status });
     }
     const json = await res.json();
     return parseGraphQLResponse(json, dataPath);

package/lib/Socket/messages-recv.js

@@ -523,6 +523,19 @@ export const makeMessagesRecvSocket = (config) => {
                 const ref = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_ref'));
                 const primaryIdentityPublicKey = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'primary_identity_pub'));
                 const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(getBinaryNodeChildBuffer(linkCodeCompanionReg, 'link_code_pairing_wrapped_primary_ephemeral_pub'));
+                // AunuBaileys (1.0.76): Hunt-ronde-3 — toRequiredBuffer only
+                // checks PRESENCE. The wrapped ephemeral key has a fixed
+                // wire shape (32B salt + 16B IV + 32B encrypted pubkey =
+                // 80) and an identity pubkey is 32B raw / 33B prefixed;
+                // anything else is a malformed stanza. Most bad lengths
+                // already died inside libsignal BEFORE advSecretKey was
+                // assigned, but 31/32-byte inputs slipped through and
+                // derived a garbage advSecretKey that then got persisted.
+                // Refuse up front instead of deriving creds from junk.
+                if (primaryEphemeralPublicKeyWrapped.length < 80 ||
+                    (primaryIdentityPublicKey.length !== 32 && primaryIdentityPublicKey.length !== 33)) {
+                    throw new Boom('link_code_companion_reg: malformed key material in server stanza — refusing to derive pairing secrets from it', { statusCode: 400 });
+                }
                 const codePairingPublicKey = await decipherLinkPublicKey(primaryEphemeralPublicKeyWrapped);
                 const companionSharedKey = Curve.sharedKey(authState.creds.pairingEphemeralKeyPair.private, codePairingPublicKey);
                 const random = randomBytes(32);

package/lib/Socket/messages-send.js

@@ -334,12 +334,23 @@ export const makeMessagesSocket = (config) => {
             // the transport to reopen, bounded by connectTimeoutMs; a connection
             // that closes for good still fails fast via waitForSocketOpen itself.
             const waitMs = config.connectTimeoutMs ?? 60000;
-            await Promise.race([
-                waitForSocketOpen(),
-                delay(waitMs).then(() => {
-                    throw new Boom(`Timed out waiting ${waitMs}ms for the connection to open before sending`, { statusCode: 408 }); // 408 = DisconnectReason.timedOut
-                })
-            ]);
+            const openWait = waitForSocketOpen();
+            try {
+                await Promise.race([
+                    openWait,
+                    delay(waitMs).then(() => {
+                        throw new Boom(`Timed out waiting ${waitMs}ms for the connection to open before sending`, { statusCode: 408 }); // 408 = DisconnectReason.timedOut
+                    })
+                ]);
+            }
+            catch (err) {
+                // AunuBaileys (1.0.77, HB-167): when the timeout wins,
+                // the socket-open waiter is still pending — detach its
+                // ws listeners now instead of leaving three behind per
+                // failed send until the socket settles on its own.
+                openWait.cancel?.();
+                throw err;
+            }
         }
         // AunuBaileys (1.0.68): fail with a clear Boom instead of a raw
         // TypeError when sending before pairing completes or with a

package/lib/Socket/socket.js

@@ -92,6 +92,15 @@ export const makeSocket = (config) => {
     let epoch = 1;
     let keepAliveReq;
     let qrTimer;
+    // AunuBaileys (1.0.77, HB-243): true while a pair-device QR chain
+    // is cycling — a duplicate pair-device IQ must not start a second
+    // chain on the shared qrTimer slot.
+    let qrChainActive = false;
+    // AunuBaileys (1.0.77, HB-213): resolved when the Noise handshake
+    // completes (finishInit in validateConnection), so the pairing
+    // request can wait for an encrypted channel.
+    let resolveHandshakeComplete;
+    const handshakeComplete = new Promise((resolve) => { resolveHandshakeComplete = resolve; });
     let closed = false;
     let lastDisconnectError;
     const uqTagId = generateMdTagPrefix();
@@ -226,6 +235,7 @@ export const makeSocket = (config) => {
             }
         }).finish());
         noise.finishInit();
+        resolveHandshakeComplete?.();
         startKeepAliveRequest();
     };
     const getAvailablePreKeysOnServer = async () => {
@@ -278,12 +288,17 @@ export const makeSocket = (config) => {
             await uploadPreKeys();
         }
     };
+    // AunuBaileys (1.0.77, HB-156): decodeFrame invocations must never
+    // overlap — the noise handler slices ONE shared inBytes buffer, so
+    // two concurrent calls interleave and deliver stanzas out of wire
+    // order. Every WS message is chained through a single queue.
+    let frameDecodeChain = Promise.resolve();
     const onMessageReceived = (data) => {
         // AunuBaileys (1.0.67): decodeFrame is async — a malformed frame
         // (bad GCM tag, truncated binary node) or a throwing frame
         // listener must not become an unhandled rejection that kills
         // the process; route failures to onUnexpectedError instead.
-        Promise.resolve(noise.decodeFrame(data, frame => {
+        frameDecodeChain = frameDecodeChain.then(() => noise.decodeFrame(data, frame => {
             // reset ping timeout
             lastDateRecv = new Date();
             let anyTriggered = false;
@@ -311,7 +326,20 @@ export const makeSocket = (config) => {
                     logger.debug({ unhandled: true, msgId, fromMe: false, frame }, 'communication recv');
                 }
             }
-        })).catch(err => onUnexpectedError(err, 'onMessageReceived'));
+        })).catch(err => {
+            // AunuBaileys (1.0.77, HB-185/HB-207): a frame-layer failure
+            // (oversize header, GCM decrypt failure) leaves the noise
+            // stream unrecoverable — the header is never consumed, or
+            // the read counter desyncs so every later frame fails too.
+            // End the connection so the host reconnects at once instead
+            // of wedging until the keep-alive watchdog notices (~65s).
+            if (err?.isFrameFatal) {
+                end(err);
+            }
+            else {
+                onUnexpectedError(err, 'onMessageReceived');
+            }
+        });
     };
     // AunuBaileys: socket end handlers (pola v7) + fetch Mex (dari @itsliaaa/baileys)
     const socketEndHandlers = [];
@@ -329,6 +357,7 @@ export const makeSocket = (config) => {
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
         clearInterval(keepAliveReq);
         clearTimeout(qrTimer);
+        qrChainActive = false;
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
@@ -354,16 +383,20 @@ export const makeSocket = (config) => {
         ev.removeAllListeners('connection.update');
         ev.destroy?.();
     };
-    const waitForSocketOpen = async () => {
+    const waitForSocketOpen = () => {
         if (ws.isOpen) {
-            return;
+            const resolved = Promise.resolve();
+            resolved.cancel = () => { };
+            return resolved;
         }
         if (ws.isClosed || ws.isClosing) {
-            throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
+            const rejected = Promise.reject(new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+            rejected.cancel = () => { };
+            return rejected;
         }
         let onOpen;
         let onClose;
-        await new Promise((resolve, reject) => {
+        const promise = new Promise((resolve, reject) => {
             onOpen = () => resolve(undefined);
             onClose = mapWebSocketError(reject);
             ws.on('open', onOpen);
@@ -374,6 +407,16 @@ export const makeSocket = (config) => {
             ws.off('close', onClose);
             ws.off('error', onClose);
         });
+        // AunuBaileys (1.0.77, HB-167/HB-179): a caller that stops
+        // waiting (its own timeout won the race) can detach these
+        // listeners immediately instead of leaving them on the ws
+        // emitter until the socket happens to open/close/error.
+        promise.cancel = () => {
+            ws.off('open', onOpen);
+            ws.off('close', onClose);
+            ws.off('error', onClose);
+        };
+        return promise;
     };
     const keepAliveTick = () => {
         if (!lastDateRecv) {
@@ -501,15 +544,55 @@ export const makeSocket = (config) => {
                 reject(new Boom(`requestPairingCode: socket did not open within ${PAIRING_READY_TIMEOUT_MS / 1000}s (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.timedOut }));
             }, PAIRING_READY_TIMEOUT_MS);
         });
+        const rawOpenWait = waitForSocketOpen();
         try {
             await Promise.race([
-                waitForSocketOpen().catch(() => {
+                rawOpenWait.catch(() => {
                     throw new Boom(`requestPairingCode: connection closed while waiting for the socket to open (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed });
                 }),
                 closedWhileWaiting,
                 timedOut
             ]);
         }
+        finally {
+            clearTimeout(timer);
+            // AunuBaileys (1.0.77, HB-179): if the timeout or the close
+            // guard won the race, the socket-open waiter is still
+            // pending — detach its ws listeners now instead of leaving
+            // them behind until the socket settles on its own.
+            rawOpenWait.cancel?.();
+            if (onUpdate) {
+                try {
+                    ev.off('connection.update', onUpdate);
+                }
+                catch { }
+            }
+        }
+    };
+    // AunuBaileys (1.0.77, HB-213): the pairing IQ must not leave
+    // before the Noise handshake completes — encodeFrame encrypts
+    // only once the handshake is finished, so an early IQ travels as
+    // a plaintext binary node; a strict server kills the connection
+    // over it while requestPairingCode still resolves with the code.
+    const waitForHandshakeComplete = async () => {
+        let onUpdate;
+        const closedWhileWaiting = new Promise((_, reject) => {
+            onUpdate = (update) => {
+                if (update.connection === 'close') {
+                    reject(new Boom(`requestPairingCode: connection closed while waiting for the handshake to complete (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed }));
+                }
+            };
+            ev.on('connection.update', onUpdate);
+        });
+        let timer;
+        const timedOut = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new Boom(`requestPairingCode: handshake did not complete within ${PAIRING_READY_TIMEOUT_MS / 1000}s (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.timedOut }));
+            }, PAIRING_READY_TIMEOUT_MS);
+        });
+        try {
+            await Promise.race([handshakeComplete, closedWhileWaiting, timedOut]);
+        }
         finally {
             clearTimeout(timer);
             if (onUpdate) {
@@ -534,13 +617,20 @@ export const makeSocket = (config) => {
         pairingCodeRequestInFlight = true;
         try {
         await waitForPairingReady();
+        await waitForHandshakeComplete();
         authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
             id: jidEncode(phoneNumber, 's.whatsapp.net'),
             name: '~'
         };
         ev.emit('creds.update', authState.creds);
-        await sendNode({
+        // AunuBaileys (1.0.77, HB-191): query(), not sendNode() — the
+        // companion_hello result must be awaited and error-checked.
+        // sendNode resolved when the bytes hit the wire, so a server
+        // rejection left the optimistic creds.me/pairingCode persisted
+        // and sent the next boot into a 401 loop; a rejection now
+        // lands in the catch below, which rolls the creds back.
+        await query({
             tag: 'iq',
             attrs: {
                 to: S_WHATSAPP_NET,
@@ -644,6 +734,16 @@ export const makeSocket = (config) => {
         }
     });
     ws.on('error', mapWebSocketError(end));
+    // AunuBaileys (1.0.77, HB-189): the ws client forwards
+    // 'unexpected-response', which suppresses ws's own handshake
+    // abort — without a listener here a non-101 response (403/502,
+    // ISP intercept page) wedges the socket in 'connecting' forever:
+    // no open, no error, no close, and the host never reconnects.
+    ws.on('unexpected-response', (_req, res) => {
+        const code = res?.statusCode;
+        const statusCode = Number.isFinite(code) && code >= 400 && code <= 599 ? code : 500;
+        end(new Boom(`Unexpected server response: ${code}`, { statusCode }));
+    });
     ws.on('close', () => end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
     // the server terminated the connection
     ws.on('CB:xmlstreamend', () => end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
@@ -662,6 +762,16 @@ export const makeSocket = (config) => {
             }
         };
         await sendNode(iq);
+        // AunuBaileys (1.0.77, HB-243): a duplicate pair-device IQ
+        // (server retry) must not start a parallel QR chain — both
+        // chains share the single qrTimer slot, so the orphaned first
+        // chain keeps cycling after login and its ref exhaustion ends
+        // the healthy, freshly logged-in connection.
+        if (qrChainActive) {
+            logger.warn('ignoring duplicate pair-device IQ: a QR chain is already running');
+            return;
+        }
+        qrChainActive = true;
         const pairDeviceNode = getBinaryNodeChild(stanza, 'pair-device');
         const refNodes = getBinaryNodeChildren(pairDeviceNode, 'ref');
         const noiseKeyB64 = Buffer.from(creds.noiseKey.public).toString('base64');
@@ -670,6 +780,7 @@ export const makeSocket = (config) => {
         let qrMs = qrTimeout || 60000; // time to let a QR live
         const genPairQR = () => {
             if (!ws.isOpen) {
+                qrChainActive = false;
                 return;
             }
             const refNode = refNodes.shift();
@@ -726,6 +837,7 @@ export const makeSocket = (config) => {
             await sendPassiveIq('active');
             logger.info('opened connection to WA');
             clearTimeout(qrTimer); // will never happen in all likelyhood -- but just in case WA sends success on first try
+            qrChainActive = false;
             ev.emit('creds.update', { me: { ...authState.creds.me, lid: node.attrs.lid } });
             ev.emit('connection.update', { connection: 'open' });
         }
@@ -737,9 +849,9 @@ export const makeSocket = (config) => {
     // AunuBaileys (1.0.71): 405 client_too_old — fetch the live WA Web
     // build so the caller's reconnect uses it (donor: violetix
     // lib/Socket/socket.js CB:failure handler). Only for static versions;
-    // a resolver function re-resolves on the next connect anyway. The
-    // connection.update signal is best-effort: end() may already have
-    // torn the listeners down by the time the fetch lands.
+    // a resolver function re-resolves on the next connect anyway. Both
+    // 405 paths (CB:failure and CB:stream:error) await this before
+    // end(), so the clientTooOld signal reaches the host first.
     const handleClientTooOld = async () => {
         if (typeof config.version === 'function') {
             return;
@@ -759,11 +871,16 @@ export const makeSocket = (config) => {
             logger.warn({ err }, 'failed to fetch the latest WA Web version after a 405');
         }
     };
-    ws.on('CB:stream:error', (node) => {
+    ws.on('CB:stream:error', async (node) => {
         logger.error({ node }, 'stream errored out');
         const { reason, statusCode } = getErrorCodeFromStreamError(node);
         if (statusCode === 405) {
-            void handleClientTooOld();
+            // AunuBaileys (1.0.77, HB-148): awaited like the CB:failure
+            // path (1.0.72) — firing it void let end() tear the
+            // connection.update listeners down before the version
+            // fetch landed, so the clientTooOld signal never reached
+            // the host and a 405 looked like any other disconnect.
+            await handleClientTooOld();
         }
         end(new Boom(`Stream Errored (${reason})`, { statusCode, data: node }));
     });
@@ -802,7 +919,7 @@ export const makeSocket = (config) => {
         if (offlineDrainBatches >= OFFLINE_DRAIN_MAX_BATCHES) {
             stopOfflineDrain();
             logger.warn({ batches: offlineDrainBatches }, 'offline drain hit the batch cap; remaining backlog waits for the next reconnect');
-            return;
+            return false;
         }
         offlineDrainBatches += 1;
         // AunuBaileys (1.0.70): a floating sendNode here could reject
@@ -812,12 +929,19 @@ export const makeSocket = (config) => {
             attrs: {},
             content: [{ tag: 'offline_batch', attrs: { count: '100' } }]
         }).catch(err => logger.warn({ err }, 'failed to request offline batch'));
+        return true;
     };
     const scheduleOfflineDrain = () => {
         stopOfflineDrain();
         offlineDrainTimer = setTimeout(() => {
-            requestOfflineBatch();
-            scheduleOfflineDrain();
+            // AunuBaileys (1.0.77, HB-109): stop re-arming at the batch
+            // cap — the unconditional re-schedule used to undo
+            // requestOfflineBatch's stopOfflineDrain(), so when the
+            // terminal offline bulletin never arrived the cap warning
+            // repeated every 500ms for the life of the socket.
+            if (requestOfflineBatch()) {
+                scheduleOfflineDrain();
+            }
         }, OFFLINE_DRAIN_INTERVAL_MS);
     };
     ws.on('CB:ib,,offline_preview', (node) => {

package/lib/Utils/generics.js

@@ -374,6 +374,16 @@ export const getCallStatusFromNode = ({ tag, attrs }) => {
 };
 const UNEXPECTED_SERVER_CODE_TEXT = 'Unexpected server response: ';
 export const getCodeFromWSError = (error) => {
+    // AunuBaileys (1.0.77, HB-133): an error that already carries a
+    // valid Boom status code keeps it. Re-deriving the code from the
+    // message text lost real codes — promiseTimeout's Boom
+    // 'Timed Out' (408) was re-wrapped as a 500 by mapWebSocketError
+    // because the textual timeout check below is case-sensitive
+    // ('Timed Out' vs 'timed out').
+    const existingCode = error?.output?.statusCode;
+    if (Number.isFinite(existingCode) && existingCode >= 400 && existingCode <= 599) {
+        return existingCode;
+    }
     let statusCode = 500;
     if (error?.message?.includes(UNEXPECTED_SERVER_CODE_TEXT)) {
         const code = +error?.message.slice(UNEXPECTED_SERVER_CODE_TEXT.length);
@@ -385,7 +395,7 @@ export const getCodeFromWSError = (error) => {
     // AunuBaileys (1.0.67): error.code can be numeric (e.g. WS close
     // 1006) — only call startsWith on strings.
     (typeof error?.code === 'string' && error.code.startsWith('E')) ||
-        error?.message?.includes('timed out')) {
+        error?.message?.toLowerCase().includes('timed out')) {
         // handle ETIMEOUT, ENOTFOUND etc
         statusCode = 408;
     }

package/lib/Utils/make-mutex.js

@@ -1,7 +1,13 @@
 export const makeMutex = () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let task = Promise.resolve();
-    let taskTimeout;
+    // AunuBaileys (1.0.76): Hunt-ronde-3 — the old `taskTimeout` was dead
+    // code (declared, cleared in a finally, NEVER assigned — there is no
+    // hidden timeout safety net, and inventing one that breaks the chain
+    // would corrupt the serialization this mutex exists for). Removed.
+    // Note: a task that never settles blocks later tasks by design — that
+    // is what a serial mutex means (upstream parity); callers must not
+    // await unbounded work inside mutex sections.
     return {
         mutex(code) {
             task = (async () => {
@@ -11,14 +17,8 @@ export const makeMutex = () => {
                     await task;
                 }
                 catch { }
-                try {
-                    // execute the current task
-                    const result = await code();
-                    return result;
-                }
-                finally {
-                    clearTimeout(taskTimeout);
-                }
+                // execute the current task
+                return await code();
             })();
             // we replace the existing task, appending the new piece of execution to it
             // so the next task will have to wait for this one to finish

package/lib/Utils/messages-media.js

@@ -601,11 +601,24 @@ const toSmallestChunkSize = (num) => {
     return Math.floor(num / AES_CHUNK_SIZE) * AES_CHUNK_SIZE;
 };
 export const getUrlFromDirectPath = (directPath, fallbackHost) => `https://${fallbackHost || DEF_HOST}${directPath}`;
+// AunuBaileys (1.0.76): Hunt-ronde-3 — WhatsApp media is only ever served
+// from WhatsApp/Facebook CDN hosts. A sender-supplied URL whose host is
+// anything else is not a media URL, it is an SSRF attempt (the bot would
+// happily GET an internal https host with the sender's directPath glued
+// on). Non-WA hosts are never fetched: with a directPath we fall back to
+// the canonical media host (the path is globally valid there); without
+// one the download is refused.
+const WA_MEDIA_HOST_SUFFIXES = ['.whatsapp.net', '.fbcdn.net'];
+const isWAMediaHost = (hostname) => !!hostname &&
+    (hostname === 'whatsapp.net' || hostname === 'fbcdn.net' ||
+        WA_MEDIA_HOST_SUFFIXES.some((suffix) => hostname.endsWith(suffix)));
 export const downloadContentFromMessage = async ({ mediaKey, directPath, url }, type, opts = {}) => {
     // AunuBaileys (1.0.69): the sender-supplied URL used to be trusted
     // verbatim (host + path) — a remote peer could trigger a GET to an
     // arbitrary https host. Like upstream v7, only the host is taken
     // from the URL; the path is rebuilt from our own directPath.
+    // AunuBaileys (1.0.76): the host is now ALSO allowlisted (above) —
+    // a non-WA host falls back to mmg.whatsapp.net instead of being fetched.
     let downloadUrl;
     if (directPath) {
         let host;
@@ -613,10 +626,18 @@ export const downloadContentFromMessage = async ({ mediaKey, directPath, url },
             host = new URL(url || '').hostname || undefined;
         }
         catch { }
+        if (!isWAMediaHost(host)) {
+            host = undefined;
+        }
         downloadUrl = getUrlFromDirectPath(directPath, host);
     }
     else {
-        downloadUrl = url?.startsWith('https://') ? url : undefined;
+        let parsed;
+        try {
+            parsed = new URL(url || '');
+        }
+        catch { }
+        downloadUrl = parsed?.protocol === 'https:' && isWAMediaHost(parsed.hostname) ? url : undefined;
     }
     if (!downloadUrl) {
         throw new Boom('No valid media URL or directPath present in message', { statusCode: 400 });
@@ -628,7 +649,7 @@ export const downloadContentFromMessage = async ({ mediaKey, directPath, url },
  * Decrypts and downloads an AES256-CBC encrypted file given the keys.
  * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
  * */
-export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, { startByte, endByte, options } = {}) => {
+export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv, macKey }, { startByte, endByte, options } = {}) => {
     let bytesFetched = 0;
     let startChunk = 0;
     let firstBlockIsIV = false;
@@ -661,6 +682,35 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
     });
     let remainingBytes = Buffer.from([]);
     let aes;
+    // AunuBaileys (1.0.76): Hunt-ronde-3 — the downloaded ciphertext used
+    // to be decrypted with NO integrity check: the 10-byte HMAC-SHA256
+    // (macKey, iv || ciphertext) that WhatsApp appends to every media
+    // file was silently dropped with the trailing partial block, so a
+    // tampering server/CDN could alter media undetected (AES-CBC padding
+    // only catches damage to the final block). For FULL downloads (no
+    // byte range) with a macKey available, verify it: HMAC every
+    // ciphertext byte except a held-back final 10, compare in final().
+    // Ranged downloads fetch a slice that excludes the MAC — they skip
+    // verification, exactly like before. Consumers of the stream still
+    // receive plaintext progressively, but a failed check errors the
+    // stream in final(), so buffered consumers (downloadMediaMessage
+    // 'buffer') discard the content wholesale.
+    const verifyMac = !!macKey && !startByte && !endByte;
+    const macHmac = verifyMac ? Crypto.createHmac('sha256', macKey).update(iv) : null;
+    let macTail = Buffer.alloc(0);
+    const feedMac = (chunk) => {
+        if (!macHmac) {
+            return;
+        }
+        const joined = macTail.length ? Buffer.concat([macTail, chunk]) : chunk;
+        if (joined.length > 10) {
+            macHmac.update(joined.subarray(0, joined.length - 10));
+            macTail = joined.subarray(joined.length - 10);
+        }
+        else {
+            macTail = joined;
+        }
+    };
     const pushBytes = (bytes, push) => {
         if (startByte || endByte) {
             const start = bytesFetched >= startByte ? undefined : Math.max(startByte - bytesFetched, 0);
@@ -680,6 +730,7 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
     };
     const output = new Transform({
         transform(chunk, _, callback) {
+            feedMac(chunk);
             let data = Buffer.concat([remainingBytes, chunk]);
             const decryptLength = toSmallestChunkSize(data.length);
             remainingBytes = data.slice(decryptLength);
@@ -715,11 +766,19 @@ export const downloadEncryptedContent = async (downloadUrl, { cipherKey, iv }, {
             }
             try {
                 pushBytes(aes.final(), b => this.push(b));
-                callback();
             }
             catch (error) {
                 callback(error);
+                return;
+            }
+            if (macHmac) {
+                const expectedMac = macHmac.digest().subarray(0, 10);
+                if (macTail.length !== 10 || !Crypto.timingSafeEqual(Buffer.from(macTail), expectedMac)) {
+                    callback(new Boom('Downloaded media failed HMAC integrity verification — the file was tampered with or truncated in transit; refusing it', { statusCode: 400 }));
+                    return;
+                }
             }
+            callback();
         }
     });
     // AunuBaileys (1.0.71): stream.pipe() does NOT forward source

package/lib/Utils/noise-handler.js

@@ -15,8 +15,8 @@ const generateIV = (counter) => {
 // corrupt header either wedges the stream forever (size 0: the header
 // is never consumed, so every later call re-reads it) or buffers
 // without bound waiting for megabytes that never arrive. Fail loudly
-// instead: the socket ends (the caller routes the throw to
-// onUnexpectedError) and the host reconnects.
+// instead: the throw is marked frame-fatal (1.0.77, HB-185) and the
+// caller ends the socket, so the host reconnects at once.
 const MAX_NOISE_FRAME_SIZE = 10 * 1024 * 1024;
 export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }) => {
     logger = logger.child({ class: 'ns' });
@@ -161,23 +161,55 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
                 }
                 if (size > MAX_NOISE_FRAME_SIZE) {
                     // AunuBaileys (1.0.73, HB-91): never wait for a
-                    // frame that cannot exist — throw so the socket
-                    // ends instead of buffering without bound until
-                    // the keep-alive watchdog kills the connection
-                    // ~65s later.
-                    throw new Boom(`noise frame too large: ${size} bytes`, { statusCode: 400 });
+                    // frame that cannot exist. (1.0.77, HB-185): the
+                    // throw alone did NOT end the socket — the caller
+                    // only logged it, the header was never consumed,
+                    // and the stream wedged until the keep-alive
+                    // watchdog fired ~65s later. Marked frame-fatal:
+                    // the caller now ends the connection on it.
+                    const err = new Boom(`noise frame too large: ${size} bytes`, { statusCode: 400 });
+                    err.isFrameFatal = true;
+                    throw err;
                 }
                 if (inBytes.length < size + 3) {
                     break;
                 }
                 let frame = inBytes.slice(3, size + 3);
                 inBytes = inBytes.slice(size + 3);
+                let decoded = true;
                 if (isFinished) {
-                    const result = decrypt(frame);
-                    frame = await decodeBinaryNode(result);
+                    let result;
+                    try {
+                        result = decrypt(frame);
+                    }
+                    catch (err) {
+                        // AunuBaileys (1.0.77, HB-207): a GCM failure
+                        // leaves readCounter behind the server's
+                        // counter, so every later frame decrypts with
+                        // the wrong IV and fails too — the stream can
+                        // never resync. Frame-fatal: the caller ends
+                        // the connection instead of losing every
+                        // inbound message until the watchdog fires.
+                        err.isFrameFatal = true;
+                        throw err;
+                    }
+                    try {
+                        frame = await decodeBinaryNode(result);
+                    }
+                    catch (err) {
+                        // AunuBaileys (1.0.77): stanza-level corruption
+                        // is NOT fatal — the frame was consumed and the
+                        // counter advanced, so the stream is still in
+                        // sync. Log and skip the frame instead of
+                        // aborting the rest of the buffered frames.
+                        logger.error({ err }, 'failed to decode a stanza; skipping the frame');
+                        decoded = false;
+                    }
+                }
+                if (decoded) {
+                    logger.trace({ msg: frame?.attrs?.id }, 'recv frame');
+                    onFrame(frame);
                 }
-                logger.trace({ msg: frame?.attrs?.id }, 'recv frame');
-                onFrame(frame);
                 size = getBytesSize();
             }
         }

package/lib/Utils/session-watchdog.js

@@ -8,8 +8,10 @@
 //   - 'connection.update' { sessionWatchdog: { quietForMs, lastInboundAt, at } }
 // once per quiet episode (re-armed by the next inbound message).
 // Inbound traffic is observed on the event buffer ('messages.upsert' /
-// 'messages.update'); hosts that see raw frames can also call
-// watchdog.markInbound() directly. Wiring is opt-in: lib/Socket/index.js
+// 'messages.update') AND — since 1.0.76 — on the raw WebSocket frame
+// stream when sock.ws is reachable (buffered delivery is deferred during
+// long syncs, which used to read as a false deaf session); hosts can
+// also call watchdog.markInbound() directly. Wiring is opt-in: lib/Socket/index.js
 // attaches it only when config.sessionWatchdog is set (object = options,
 // true = defaults). The interval timer is unref'd so it never keeps a
 // process alive on its own.
@@ -84,6 +86,12 @@ export const makeSessionWatchdog = (sock, options = {}) => {
         ev.off?.('messages.upsert', markInbound);
         ev.off?.('messages.update', markInbound);
         ev.off?.('connection.update', onConnectionUpdate);
+        if (rawWs) {
+            rawWs.off?.('message', markInbound);
+            if (!rawWs.off && typeof rawWs.removeListener === 'function') {
+                rawWs.removeListener('message', markInbound);
+            }
+        }
         return watchdog;
     };
     const getState = () => ({
@@ -95,6 +103,19 @@ export const makeSessionWatchdog = (sock, options = {}) => {
     ev.on('messages.upsert', markInbound);
     ev.on('messages.update', markInbound);
     ev.on('connection.update', onConnectionUpdate);
+    // AunuBaileys (1.0.76): Hunt-ronde-3 — ALSO observe the raw WebSocket
+    // frame stream when available. messages.upsert/update travel through
+    // the event buffer, which DEFERS delivery to listeners while a
+    // buffered function runs (app-state resync, history processing): real
+    // inbound messages then fail to re-arm the watchdog for the whole
+    // buffering window and a long sync reads as a deaf session — a false
+    // alert. Raw frames are never buffered, and for a deaf-session
+    // detector any inbound frame (message, receipt, IQ, keep-alive reply)
+    // is the truer liveness signal anyway. Detached again in stop().
+    const rawWs = sock.ws && typeof sock.ws.on === 'function' ? sock.ws : null;
+    if (rawWs) {
+        rawWs.on('message', markInbound);
+    }
     const watchdog = {
         markInbound,
         noteInbound: markInbound,

package/lib/Utils/use-multi-file-auth-state.js

@@ -45,7 +45,14 @@ export const useMultiFileAuthState = async (folder, logger) => {
             try {
                 // AunuBaileys: atomic write (tmp + rename) anti-korupsi sesi — terinspirasi @itsliaaa/baileys
                 const tmpPath = `${filePath}.tmp-${process.pid}`;
-                await writeFile(tmpPath, JSON.stringify(data, BufferJSON.replacer));
+                // AunuBaileys (1.0.76): Hunt-ronde-3 — these files hold
+                // private keys (creds.json, session/sender-key records).
+                // They used to be created with default permissions (0644
+                // on a typical umask) — readable by every local user on a
+                // shared host. Write the tmp file 0600; the rename carries
+                // the mode onto the target, so pre-existing 0644 files
+                // also self-heal to 0600 on their next save.
+                await writeFile(tmpPath, JSON.stringify(data, BufferJSON.replacer), { mode: 0o600 });
                 await rename(tmpPath, filePath);
             }
             catch (err) {

package/lib/WABinary/decode.js

@@ -3,9 +3,24 @@ import { inflate } from 'zlib';
 import * as constants from './constants.js';
 import { jidEncode } from './jid-utils.js';
 const inflatePromise = promisify(inflate);
+// AunuBaileys (1.0.76): Hunt-ronde-3 — inflate used to run with NO output
+// cap: zlib expands up to ~1000x, so a max-size wire frame (10 MiB, HB-91)
+// could inflate to ~10 GB and OOM the process. 128 MiB is far above any
+// legitimate stanza (wire stanzas are messages / IQ results / app-state
+// patches — big payloads travel as media downloads, not stanzas) while
+// still stopping a bomb cold. Exceeding it is a clean decode failure.
+const MAX_DECOMPRESSED_SIZE = 128 * 1024 * 1024;
 export const decompressingIfRequired = async (buffer) => {
     if (2 & buffer.readUInt8()) {
-        buffer = await inflatePromise(buffer.slice(1));
+        try {
+            buffer = await inflatePromise(buffer.slice(1), { maxOutputLength: MAX_DECOMPRESSED_SIZE });
+        }
+        catch (err) {
+            if (err?.code === 'ERR_BUFFER_TOO_LARGE') {
+                throw new Error(`AunuBaileys: compressed stanza exceeds the ${MAX_DECOMPRESSED_SIZE / (1024 * 1024)} MiB decompressed-size cap — refusing to inflate (possible zlib bomb)`);
+            }
+            throw err;
+        }
     }
     else {
         // nodes with no compression have a 0x00 prefix, we remove that
@@ -13,7 +28,18 @@ export const decompressingIfRequired = async (buffer) => {
     }
     return buffer;
 };
-export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) => {
+// AunuBaileys (1.0.76): Hunt-ronde-3 — the decoder recursed with NO depth
+// bound: ~5 wire bytes buy one nesting level, so a ~100 KB stanza reached
+// depth 20,000 and died as an uncontrolled RangeError (stack overflow).
+// Legit stanzas nest < ~20 deep; 512 is generous headroom, and crossing it
+// is a descriptive decode error instead of a V8 crash. (Total node count
+// needs no separate cap: every node consumes >= 1 input byte, so count is
+// bounded by the — now also capped — buffer length.)
+const MAX_NODE_DEPTH = 512;
+export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }, depth = 0) => {
+    if (depth > MAX_NODE_DEPTH) {
+        throw new Error(`AunuBaileys: binary node nesting exceeds the ${MAX_NODE_DEPTH}-level safety cap — refusing to decode (possible depth bomb)`);
+    }
     const { DOUBLE_BYTE_TOKENS, SINGLE_BYTE_TOKENS, TAGS } = opts;
     const checkEOS = (length) => {
         if (indexRef.index + length > buffer.length) {
@@ -186,7 +212,7 @@ export const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0
         const items = [];
         const size = readListSize(tag);
         for (let i = 0; i < size; i++) {
-            items.push(decodeDecompressedBinaryNode(buffer, opts, indexRef));
+            items.push(decodeDecompressedBinaryNode(buffer, opts, indexRef, depth + 1));
         }
         return items;
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.75",
+  "version": "1.0.77",
   "description": "AunuBaileys — the self-healing WhatsApp Web API for Node.js. Bad MAC and \"2000 messages into the future\" errors repair themselves, LID and phone-number identities stay in sync, anti-ban is built in, pairing codes are custom — plus 29 experimental features no other Baileys fork ships: invisible watermarks, per-person tag-all cards, side-profile text, ghost mentions and more. ESM, CJS and full TypeScript types.",
   "keywords": [
     "whatsapp",