whalibmob 5.5.82 → 5.5.83

package/lib/messages/MessageSender.js

@@ -1127,14 +1127,30 @@ class MessageSender {
         : this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal)
     ]);
 
-    // Dedupe: a device reached through more than one path must still appear
-    // exactly once in <participants>. The sending device is filtered out again
-    // here in case a member list named us under an address the walk above did
-    // not recognise.
+    // Every device this group resolves to, our own primary included, deduped so
+    // a device reached through more than one path is counted once. whatsmeow
+    // hashes GetUserDevices(groupParticipants) in exactly this shape — the whole
+    // enumeration, sending device and all — and drops hosted endpoints first,
+    // since those are bot-side and never real participants.
+    const isHostedJid = (jid) => {
+      const s = String(jid);
+      return s.endsWith('@hosted') || s.endsWith('@hosted.lid');
+    };
+    const enumeratedDevices = [...new Set(
+      [...memberDevices, ...lidDevices, ...ownTargets, selfJid]
+    )].filter(jid => !isHostedJid(jid));
+
+    // The participant hash the server checks the fan-out against. whatsmeow puts
+    // it on group stanzas (sendGroup sets node.Attrs["phash"]) and nowhere else;
+    // it is computed over the enumeration above, not over the encryption targets,
+    // so the sending device counts here even though it is not a recipient.
+    const phash = computePhash(enumeratedDevices);
+
+    // Targets to actually encrypt for: everything but the sending device. Both
+    // Baileys and whatsmeow skip it explicitly at this point and not before.
     const selfAddrs = new Set([adString(`${ownPhone}@s.whatsapp.net`)]);
     if (myLidUser) selfAddrs.add(adString(`${myLidUser}@lid`));
-    const allTargets = [...new Set([...memberDevices, ...lidDevices, ...ownTargets])]
-      .filter(jid => !selfAddrs.has(adString(jid)));
+    const allTargets = enumeratedDevices.filter(jid => !selfAddrs.has(adString(jid)));
 
     const skStore        = this._signal.senderKeyStore;
     const existingSkdmMap = skStore.getSKDMMap(groupJid);
@@ -1192,16 +1208,16 @@ class MessageSender {
     if (mediaSubtype) skmsgAttrs.mediatype = mediaSubtype;
     msgContent.push(new BinaryNode('enc', skmsgAttrs, Buffer.isBuffer(skmsgCiphertext) ? skmsgCiphertext : Buffer.from(skmsgCiphertext)));
 
-    // No phash on group stanzas. Baileys computes a participant hash only on
-    // the 1:1 path; a group message carries id/to/type/addressing_mode and
-    // nothing else. Sending a hash the server did not ask for — over a
-    // participant set it derives itself from the group — is a way to have the
-    // stanza rejected outright.
+    // phash belongs on a group stanza and only on a group stanza — whatsmeow's
+    // sendGroup sets it, sendDM does not. It tells the server which device set we
+    // fanned out to; the server compares it against its own and echoes its hash
+    // back on the ack when they differ.
     const stanzaAttrs = {
       to: jidStrToObj(groupJid),
       id: msgId,
       type: mediaType,
       addressing_mode: groupAddressingMode,
+      phash,
       t:   String(msNow())
     };
     if (options.edit) stanzaAttrs.edit = String(options.edit);
@@ -1223,7 +1239,27 @@ class MessageSender {
     }
 
     const msgNode = new BinaryNode('message', stanzaAttrs, msgContent);
-    return this._dispatchAndAck(msgNode, msgId);
+    const dispatchResult = await this._dispatchAndAck(msgNode, msgId);
+
+    // A hash on the ack that differs from ours means the server's participant
+    // list for this group is not the one we just fanned out to, so some members
+    // did not get the message. whatsmeow drops its group cache on exactly this
+    // signal; the device lists behind the members are dropped too, so the next
+    // send re-runs group metadata and usync rather than repeating the miss.
+    if (dispatchResult && dispatchResult.phash && dispatchResult.phash !== phash) {
+      _whaDbg('[DBG] GROUP_PHASH_MISMATCH ours=' + phash +
+        ' server=' + dispatchResult.phash + ' group=' + groupJid +
+        ' — invalidating group metadata and device caches');
+      if (typeof this._client.invalidateGroupMetadata === 'function') {
+        this._client.invalidateGroupMetadata(groupJid);
+      }
+      const staleKeys = [...new Set(enumeratedDevices.map(jid =>
+        String(jid).endsWith('@lid') ? 'lid:' + phoneFromJid(jid) : phoneFromJid(jid)
+      ))];
+      if (staleKeys.length) this._devMgr.clearCache(staleKeys);
+    }
+
+    return dispatchResult;
   }
 
   // ─── Dispatch and wait for ack ────────────────────────────────────────────

package/lib/proto/MessageProto.js

@@ -60,13 +60,19 @@ function encodeDouble(fieldNum, value) {
   return Buffer.concat([t, buf]);
 }
 
+// Plain text goes in conversation (field 1). Text that carries a contextInfo —
+// a quoted reply, a mention — has to be an ExtendedTextMessage instead, which is
+// field 6 of Message: { text=1, contextInfo=17 }.
+//
+// The wrapper was being written to field 38, which is orderMessage, so replies
+// and mentions arrived as an unreadable order rather than as text.
 function encodeText(text, contextInfo) {
   if (contextInfo) {
     const inner = Buffer.concat([
       field(1,  WIRE_LEN, str(text)),
       field(17, WIRE_LEN, encodeContextInfo(contextInfo))
     ]);
-    return field(38, WIRE_LEN, inner);
+    return field(6, WIRE_LEN, inner);
   }
   return field(1, WIRE_LEN, str(text));
 }
@@ -260,8 +266,12 @@ function encodeMessage(type, payload) {
     case 'sticker':      return field(26, WIRE_LEN, payload);
     case 'reaction':     return field(46, WIRE_LEN, payload);
     case 'protocol':     return field(12, WIRE_LEN, payload);
-    case 'extendedText': return field(2,  WIRE_LEN, payload);
-    case 'poll':         return field(85, WIRE_LEN, payload);
+    // extendedTextMessage is field 6. It used to be written to field 2, which is
+    // senderKeyDistributionMessage — so an edited message went out claiming to be
+    // a SenderKey distribution, and field 2 was not free for the real one.
+    case 'extendedText': return field(6,  WIRE_LEN, payload);
+    // pollCreationMessage is field 49; field 85 is eventCoverImage.
+    case 'poll':         return field(49, WIRE_LEN, payload);
     case 'location':     return field(5,  WIRE_LEN, payload);
     case 'contact':      return field(4,  WIRE_LEN, payload);
     default:             return payload;
@@ -380,12 +390,18 @@ function decodeMessageContainer(buf) {
       if (dsm[2]) return decodeMessageContainer(dsm[2]);
     }
 
-    // Field 35: senderKeyDistributionMessage — used to set up sender keys.
+    // Field 2: senderKeyDistributionMessage — used to set up sender keys.
     // In WhatsApp Multi-Device, SKDM is bundled WITH the first real message in a new
     // session (even for 1-on-1 DMs). We extract it and continue decoding the real message.
+    //
+    // This read field 35, which is messageContextInfo. Two things followed: a real
+    // distribution from another member (always at field 2) was never seen, so their
+    // group messages stayed undecryptable; and the messageContextInfo that ordinary
+    // messages carry was fed to processSKDM as if it were a distribution, which
+    // writes junk states into the sender-key record.
     let skdmInfo = null;
-    if (f[35]) {
-      const skdm = _decodeFields(f[35]);
+    if (f[2]) {
+      const skdm = _decodeFields(f[2]);
       // field 1 = groupId (string), field 2 = axolotlSenderKeyDistributionMessage (bytes)
       skdmInfo = {
         groupId: _str(skdm[1]),
@@ -403,10 +419,10 @@ function decodeMessageContainer(buf) {
       if (text) msgResult = { type: 'text', text };
     }
 
-    // Field 2: extendedTextMessage — field 1 = text
-    if (!msgResult && f[2] && Buffer.isBuffer(f[2])) {
+    // Field 6: extendedTextMessage — field 1 = text
+    if (!msgResult && f[6] && Buffer.isBuffer(f[6])) {
       try {
-        const ext = _decodeFields(f[2]);
+        const ext = _decodeFields(f[6]);
         const text = _str(ext[1]);
         if (text) msgResult = { type: 'text', text };
       } catch (_) {}
@@ -552,11 +568,11 @@ function decodeMessageContainer(buf) {
       } catch (_) { msgResult = { type: 'reaction', emoji: '' }; }
     }
 
-    // Field 85: pollCreationMessage
+    // Field 49: pollCreationMessage
     // encKey=1, name=2 (question), options=3 (repeated PollOption{name=1}), selectableOptionsCount=4
-    if (!msgResult && f[85] && Buffer.isBuffer(f[85])) {
+    if (!msgResult && f[49] && Buffer.isBuffer(f[49])) {
       try {
-        const poll = _decodeFields(f[85]);
+        const poll = _decodeFields(f[49]);
         const question = _str(poll[2]);
         const rawOpts  = poll[3];
         const options  = [];
@@ -574,8 +590,8 @@ function decodeMessageContainer(buf) {
       } catch (_) { msgResult = { type: 'poll', question: '', options: [] }; }
     }
 
-    // Field 89: pollUpdateMessage (a vote on an existing poll)
-    if (!msgResult && f[89] && Buffer.isBuffer(f[89])) {
+    // Field 50: pollUpdateMessage (a vote on an existing poll)
+    if (!msgResult && f[50] && Buffer.isBuffer(f[50])) {
       msgResult = { type: 'pollVote' };
     }
 
@@ -595,12 +611,20 @@ function decodeMessageContainer(buf) {
   }
 }
 
+// ─── SenderKeyDistributionMessage (field 2 of Message) ───────────────────────
+// SenderKeyDistributionMessage { groupId=1, axolotlSenderKeyDistributionMessage=2 }
+//
+// This was written to field 35, which in Message is messageContextInfo — an
+// entirely different type. Every group SenderKey we distributed was therefore
+// labelled as context metadata, so no recipient ever saw a distribution, no
+// recipient could open the sender-key session, and every skmsg we sent showed up
+// as "Waiting for this message" on their side. It is field 2 in WAProto.
 function encodeSenderKeyDistributionMessage(groupId, axolotlBytes) {
   const inner = Buffer.concat([
     field(1, WIRE_LEN, str(groupId)),
     field(2, WIRE_LEN, bytes(axolotlBytes))
   ]);
-  return field(35, WIRE_LEN, inner);
+  return field(2, WIRE_LEN, inner);
 }
 
 module.exports = {

package/lib/signal/SenderKey.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { dbg: _whaDbg } = require('../logger');
+
 const crypto = require('crypto');
 const fs     = require('fs');
 const path   = require('path');
@@ -74,6 +76,16 @@ function deriveMessageKeys(messageKey) {
 
 const _SK_DEBOUNCE_MS = 300;
 
+// Bumped whenever a change means the SenderKey distributions we already sent
+// were never usable by their recipients. The stored "who already has our key"
+// map is then dropped once on load, so the next send to each group distributes
+// again instead of trusting a record of deliveries that never landed.
+//
+// v2: the distribution was written to Message field 35 (messageContextInfo)
+//     instead of field 2, so no recipient ever received a readable one.
+const SKDM_DISTRIBUTION_FORMAT = 2;
+const SKDM_FORMAT_KEY          = '__skdmFormat__';
+
 class SenderKeyStore {
   constructor() {
     this._data      = {};
@@ -96,6 +108,27 @@ class SenderKeyStore {
         this._data = {};
       }
     }
+    this._migrateSKDMDistribution();
+  }
+
+  // Drop the "already distributed" bookkeeping once when the format changes.
+  // The sender keys themselves are kept — only the record of who has them is
+  // reset, so the next send to a group re-distributes to every member.
+  _migrateSKDMDistribution() {
+    if (this._data[SKDM_FORMAT_KEY] === SKDM_DISTRIBUTION_FORMAT) return;
+    let dropped = 0;
+    for (const key of Object.keys(this._data)) {
+      if (key.startsWith('__skdm__')) {
+        delete this._data[key];
+        dropped++;
+      }
+    }
+    this._data[SKDM_FORMAT_KEY] = SKDM_DISTRIBUTION_FORMAT;
+    this._save();
+    if (dropped > 0) {
+      _whaDbg('[DBG] SKDM_FORMAT_MIGRATION dropped ' + dropped +
+        ' stale distribution maps — every group re-distributes on next send');
+    }
   }
 
   _flushSync() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.5.82",
+  "version": "5.5.83",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",