aunubaileys 1.0.16 → 1.0.18

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.18 / Baru di 1.0.18
+
+- 🔁 **Retry receipts: the peer's own key bundle is finally used** — when a recipient device asks for a resend, its retry receipt often embeds that device's own current key bundle. Upstream ignored it and always re-fetched a bundle from the server (extra round trip, and JID→bundle mapping is fragile for LID participants). AunuBaileys now parses the bundle (new exported `parseRetryReceiptSession`, unit-verified) and injects it as the fresh session for the resend, skipping the server fetch for that resend. Receipts without a bundle behave exactly as before.
+
+### 🆕 What's new in 1.0.17 / Baru di 1.0.17
+
+- 👥 **Group sender-key heal** — the 1.0.14 failure counter now covers group messages too: after 3 consecutive group decrypt failures from the same author in the same group, the stale sender-key record is deleted (new `signalRepository.deleteSenderKey`), so the next retry makes the author resend with a fresh distribution message and the group cipher rebuilds from scratch. One rotten sender-key record can no longer mute a group member forever.
+
 ### 🆕 What's new in 1.0.16 / Baru di 1.0.16
 
 - 🪪 **Identity changes are handled, not just logged** — when WhatsApp notifies that a contact's identity changed (new phone / reinstall / recycled number), upstream Baileys logs “identity changed” and does nothing, leaving your stored session bound to the old identity so that contact's messages keep failing. AunuBaileys now deletes the stored session for that JID on the spot, so the next exchange re-initiates cleanly against the new identity.

package/lib/Signal/libsignal.js

@@ -66,6 +66,10 @@ export function makeLibSignalRepository(auth) {
                 senderKeyDistributionMessage: senderKeyDistributionMessage.serialize()
             };
         },
+        async deleteSenderKey(group, authorJid) {
+            const senderNameStr = jidToSignalSenderKeyName(group, authorJid).toString();
+            await auth.keys.set({ 'sender-key': { [senderNameStr]: null } });
+        },
         async deleteSession(jid) {
             const addr = jidToSignalProtocolAddress(jid).toString();
             await auth.keys.set({ session: { [addr]: null } });

package/lib/Socket/messages-recv.js

@@ -5,7 +5,7 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaults/index.js';
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, parseRetryReceiptSession, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -481,8 +481,7 @@ export const makeMessagesRecvSocket = (config) => {
         const newValue = (msgRetryCache.get(key) || 0) + 1;
         msgRetryCache.set(key, newValue);
     };
-    const sendMessagesAgain = async (key, ids, retryNode) => {
-        // todo: implement a cache to store the last 256 sent messages (copy whatsmeow)
+    const sendMessagesAgain = async (key, ids, retryNode, sessionPreInjected = false) => {
         const msgs = await Promise.all(ids.map(async (id) => (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config).get(key.remoteJid, id)));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
@@ -490,7 +489,9 @@ export const makeMessagesRecvSocket = (config) => {
         // just re-send the message to everyone
         // prevents the first message decryption failure
         const sendToAll = !jidDecode(participant)?.device;
-        await assertSessions([participant], true);
+        if (!sessionPreInjected) {
+            await assertSessions([participant], true);
+        }
         if (isJidGroup(remoteJid)) {
             await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } });
         }
@@ -572,7 +573,24 @@ export const makeMessagesRecvSocket = (config) => {
                             if (key.fromMe) {
                                 try {
                                     logger.debug({ attrs, key }, 'recv retry request');
-                                    await sendMessagesAgain(key, ids, retryNode);
+                                    // AunuBaileys: when the retry receipt carries the
+                                    // requester's own key bundle, build the fresh
+                                    // session from THAT (authoritative for the exact
+                                    // device, no server round trip) and skip the
+                                    // force-fetch inside sendMessagesAgain.
+                                    let sessionPreInjected = false;
+                                    const bundleSession = parseRetryReceiptSession(node);
+                                    if (bundleSession && key.participant) {
+                                        try {
+                                            await signalRepository.injectE2ESession({ jid: key.participant, session: bundleSession });
+                                            sessionPreInjected = true;
+                                            logger.debug({ participant: key.participant }, 'aunu: injected E2E session from retry receipt bundle');
+                                        }
+                                        catch (injErr) {
+                                            logger.debug({ err: injErr }, 'aunu: retry receipt bundle injection failed; falling back to server fetch');
+                                        }
+                                    }
+                                    await sendMessagesAgain(key, ids, retryNode, sessionPreInjected);
                                 }
                                 catch (error) {
                                     logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
@@ -677,18 +695,26 @@ export const makeMessagesRecvSocket = (config) => {
                                 }
                                 const encNode = getBinaryNodeChild(node, 'enc');
                                 let forceIncludeKeys = !encNode;
-                                if (!isJidGroup(msg.key.remoteJid) && author) {
+                                if (author) {
                                     try {
+                                        const isGroupMsg = isJidGroup(msg.key.remoteJid);
                                         const addr = signalRepository.jidToSignalProtocolAddress(author);
-                                        const fails = (decryptFailCounts.get(addr) || 0) + 1;
+                                        const failKey = isGroupMsg ? `sk:${msg.key.remoteJid}:${addr}` : addr;
+                                        const fails = (decryptFailCounts.get(failKey) || 0) + 1;
                                         if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
-                                            await signalRepository.deleteSession(author);
-                                            decryptFailCounts.delete(addr);
+                                            if (isGroupMsg) {
+                                                await signalRepository.deleteSenderKey(msg.key.remoteJid, author);
+                                                logger.warn({ author, group: msg.key.remoteJid }, 'aunu: deleted stale sender-key record after repeated group decrypt failures; retry request asks the author to resend with a fresh distribution message');
+                                            }
+                                            else {
+                                                await signalRepository.deleteSession(author);
+                                                logger.warn({ author, addr }, 'aunu: deleted stale E2E session after repeated decrypt failures (Bad MAC self-heal); retry receipt carries fresh keys');
+                                            }
+                                            decryptFailCounts.delete(failKey);
                                             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);
+                                            decryptFailCounts.set(failKey, fails);
                                         }
                                     }
                                     catch (healErr) {
@@ -708,7 +734,9 @@ export const makeMessagesRecvSocket = (config) => {
                     else {
                         if (author) {
                             try {
-                                decryptFailCounts.delete(signalRepository.jidToSignalProtocolAddress(author));
+                                const addr = signalRepository.jidToSignalProtocolAddress(author);
+                                decryptFailCounts.delete(addr);
+                                decryptFailCounts.delete(`sk:${msg.key.remoteJid}:${addr}`);
                             }
                             catch { }
                         }

package/lib/Types/Signal.d.ts

@@ -54,6 +54,8 @@ export type SignalRepository = {
     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>;
+    /** AunuBaileys: delete the stored sender-key record for a group author (stale group session heal). */
+    deleteSenderKey(group: string, authorJid: string): Promise<void>;
     jidToSignalProtocolAddress(jid: string): string;
 };
 export {};

package/lib/Utils/signal.d.ts

@@ -16,6 +16,8 @@ export declare const generateOrGetPreKeys: (creds: AuthenticationCreds, range: n
 export declare const xmppSignedPreKey: (key: SignedKeyPair) => BinaryNode;
 export declare const xmppPreKey: (pair: KeyPair, id: number) => BinaryNode;
 export declare const parseAndInjectE2ESessions: (node: BinaryNode, repository: SignalRepository) => Promise<void>;
+/** AunuBaileys: session parsed from a retry receipt's embedded key bundle, or undefined when absent. */
+export declare const parseRetryReceiptSession: (node: BinaryNode) => { registrationId: number; identityKey: Buffer; signedPreKey?: { keyId: number; publicKey: Buffer; signature?: Buffer }; preKey?: { keyId: number; publicKey: Buffer } } | undefined;
 export declare const extractDeviceJids: (result: USyncQueryResultList[], myJid: string, excludeZeroDevices: boolean) => JidWithDevice[];
 /**
  * get the next N keys for upload or processing

package/lib/Utils/signal.js

@@ -55,6 +55,37 @@ export const xmppPreKey = (pair, id) => ({
         { tag: 'value', attrs: {}, content: pair.public }
     ]
 });
+/** AunuBaileys: parse the E2E key bundle embedded in a retry receipt.
+ * When a recipient device asks us to resend, its receipt often carries the
+ * device's OWN current key bundle (<keys> + <registration>) — the device
+ * itself stating "build your session to me from THIS". Upstream ignores it
+ * and re-fetches a bundle from the server instead; consuming the receipt's
+ * bundle skips that round trip and, more importantly, is authoritative for
+ * the exact requesting device (server lookups by JID are fragile for LID
+ * participants). Returns undefined when the receipt carries no bundle. */
+export const parseRetryReceiptSession = (node) => {
+    const keysNode = getBinaryNodeChild(node, 'keys');
+    if (!keysNode) {
+        return undefined;
+    }
+    const identity = getBinaryNodeChildBuffer(keysNode, 'identity');
+    if (!identity) {
+        return undefined;
+    }
+    const extractKey = (key) => key
+        ? {
+            keyId: getBinaryNodeChildUInt(key, 'id', 3),
+            publicKey: generateSignalPubKey(getBinaryNodeChildBuffer(key, 'value')),
+            signature: getBinaryNodeChildBuffer(key, 'signature')
+        }
+        : undefined;
+    return {
+        registrationId: getBinaryNodeChildUInt(node, 'registration', 4),
+        identityKey: generateSignalPubKey(identity),
+        signedPreKey: extractKey(getBinaryNodeChild(keysNode, 'skey')),
+        preKey: extractKey(getBinaryNodeChild(keysNode, 'key'))
+    };
+};
 export const parseAndInjectE2ESessions = async (node, repository) => {
     const extractKey = (key) => key
         ? {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "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",