whalibmob 5.5.21 → 5.5.23

package/lib/messages/MessageSender.js

@@ -1,10 +1,11 @@
 'use strict';
 
-const crypto   = require('crypto');
+const crypto         = require('crypto');
+const { Mutex }      = require('async-mutex');
 const path     = require('path');
 const fs       = require('fs');
 const { BinaryNode }  = require('../BinaryNode');
-const { DeviceManager } = require('../DeviceManager');
+const { DeviceManager, jidStrToObj } = require('../DeviceManager');
 const {
   encodeMessage,
   encodeText, encodeImageMessage, encodeVideoMessage,
@@ -178,13 +179,19 @@ function computePhash(jids) {
 
 class MessageSender {
   constructor(client) {
-    this._client     = client;
-    this._socket     = client._socket;
-    this._store      = client._store;
-    this._signal     = client._signal;
-    this._devMgr     = client._devMgr;
-    this._mediaHosts = [];
-    this._mediaAuth  = '';
+    this._client       = client;
+    this._socket       = client._socket;
+    this._store        = client._store;
+    this._signal       = client._signal;
+    this._devMgr       = client._devMgr;
+    this._mediaHosts   = [];
+    this._mediaAuth    = '';
+    // Mutex that serialises Signal encryption across concurrent sends.
+    // Signal session state is shared per-process; concurrent encrypt calls on
+    // the same session can corrupt the ratchet chain and produce undecryptable
+    // ciphertexts.  Holding the lock for the duration of the encrypt block
+    // (not the full send) keeps serialisation cost minimal.
+    this._encryptMutex = new Mutex();
   }
 
   // Called by Client when media connection is established
@@ -553,12 +560,42 @@ class MessageSender {
     // Primary devices can always use pkmsg to establish new Signal sessions —
     // they simply omit the device-identity node (server accepts this for primaries).
     const allowPkmsg = true;
-    const [recipientDevices, ownDevices] = await Promise.all([
+
+    // First, run the phone-based usync (and own devices) in parallel.
+    // IMPORTANT: _pnToLid may be empty RIGHT NOW but gets populated during this
+    // await — incoming messages from the recipient (which arrive while we wait
+    // for the usync timeout) tell us their LID JID via from=LID + sender_pn attrs.
+    // We therefore check _pnToLid AFTER this await, not before.
+    const [_recipientDevicesByPhone, ownDevices] = await Promise.all([
       this._devMgr.bulkEnsureSessions([recipientPhone], this._signal, allowPkmsg),
       this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal, allowPkmsg)
     ]);
 
-    const otherJids     = recipientDevices.length > 0 ? recipientDevices : [toJid];
+    // ── LID routing fix ───────────────────────────────────────────────────────
+    // Check _pnToLid NOW — after the await above, incoming messages from the
+    // recipient during the usync wait will have populated this map.
+    // For LID-migrated accounts, the message `to` field AND Signal participants
+    // must use the LID JID.  Phone-JID messages are silently accepted by the
+    // server but never delivered to the recipient's LID-registered device.
+    const lidUser      = this._client._pnToLid && this._client._pnToLid.get(recipientPhone);
+    const routingToJid = lidUser ? `${lidUser}@lid` : toJid;
+
+    process.stderr.write('[DBG] DM_ROUTE phone=' + recipientPhone +
+      ' routing=' + routingToJid + (lidUser ? ' (LID)' : ' (PN)') + '\n');
+
+    let otherJids;
+    if (lidUser) {
+      // Fetch bundle + build Signal session for the LID JID.
+      // skipUsync=true: we already know the LID from _pnToLid — skip a second
+      // 15 s usync round-trip and go straight to bundle fetch (device 0 primary).
+      const lidDevices = await this._devMgr.bulkEnsureSessionsForLid(
+        lidUser, this._signal, allowPkmsg, /* skipUsync */ true);
+      otherJids = lidDevices.length > 0 ? lidDevices : [routingToJid];
+    } else {
+      otherJids = _recipientDevicesByPhone.length > 0 ? _recipientDevicesByPhone : [toJid];
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     const ownLinkedJids = ownDevices.filter(j => j !== ownMainJid);
 
     const allParticipants = [...otherJids, ...ownLinkedJids];
@@ -568,16 +605,22 @@ class MessageSender {
       ? encodeDeviceSentMessage(toJid, plaintext, phash)
       : null;
 
-    const [otherEncrypted, ownEncrypted] = await Promise.all([
-      this._signal.bulkEncryptForDevices(otherJids, plaintext),
-      ownLinkedJids.length > 0
-        ? this._signal.bulkEncryptForDevices(ownLinkedJids, dsmBuf)
-        : Promise.resolve([])
-    ]);
+    // Acquire mutex before touching Signal sessions — concurrent sends on the
+    // same session corrupt the ratchet chain and produce undecryptable messages.
+    const [otherEncrypted, ownEncrypted] = await this._encryptMutex.runExclusive(async () => {
+      const other = await this._signal.bulkEncryptForDevices(otherJids, plaintext);
+      const own   = ownLinkedJids.length > 0
+        ? await this._signal.bulkEncryptForDevices(ownLinkedJids, dsmBuf)
+        : [];
+      return [other, own];
+    });
 
     const encryptedList = [...otherEncrypted, ...ownEncrypted];
 
-    const stanzaAttrs = { to: toJid, id: msgId, type: mediaType, t: String(msNow()) };
+    // Encode the routing JID as a binary JID object (JID_PAIR for @lid / @s.whatsapp.net).
+    // Raw UTF-8 strings are not recognised by the server for LID recipients, causing
+    // the message to be accepted (server ACK) but never delivered to the device.
+    const stanzaAttrs = { to: jidStrToObj(routingToJid), id: msgId, type: mediaType, t: String(msNow()) };
     if (phash) stanzaAttrs.phash = phash;
     if (options.edit) stanzaAttrs.edit = String(options.edit);
 
@@ -599,6 +642,19 @@ class MessageSender {
 
     const msgNode = new BinaryNode('message', stanzaAttrs, msgContent);
 
+    // Debug: log outgoing stanza details
+    process.stderr.write('[DBG] DM_SEND to=' + toJid +
+      ' otherJids=[' + otherJids.join(',') + ']' +
+      ' ownLinked=[' + ownLinkedJids.join(',') + ']' +
+      ' encrypted=' + encryptedList.length +
+      ' hasPkmsg=' + hasPkmsg +
+      ' hasAdv=' + !!(advBytes) +
+      '\n');
+    if (encryptedList.length > 0) {
+      process.stderr.write('[DBG] DM_PARTICIPANTS ' +
+        encryptedList.map(e => e.jid + '(' + e.type + ')').join(', ') + '\n');
+    }
+
     // Cache plaintext so Client can re-send with fresh session on recipient retry
     if (this._client._sentMsgCache) {
       this._client._sentMsgCache.set(msgId, {
@@ -675,13 +731,18 @@ class MessageSender {
     const existingSkdmMap = skStore.getSKDMMap(groupJid);
     const skdmRecipients  = allTargets.filter(jid => !existingSkdmMap[jid]);
 
+    // Acquire mutex for all group encryption — SKDM fanout and senderKey encrypt
+    // share the same Signal session state and must not run concurrently.
     let skdmEncrypted = [];
-    if (skdmRecipients.length > 0) {
-      skdmEncrypted = await this._signal.bulkEncryptForDevices(skdmRecipients, skdmMsg);
-      skStore.markSKDMSent(groupJid, skdmRecipients);
-    }
+    let skmsgCiphertext;
+    await this._encryptMutex.runExclusive(async () => {
+      if (skdmRecipients.length > 0) {
+        skdmEncrypted = await this._signal.bulkEncryptForDevices(skdmRecipients, skdmMsg);
+        skStore.markSKDMSent(groupJid, skdmRecipients);
+      }
+      skmsgCiphertext = this._signal.senderKeyEncrypt(groupJid, senderIdentity, plaintext);
+    });
 
-    const skmsgCiphertext = this._signal.senderKeyEncrypt(groupJid, senderIdentity, plaintext);
     const phash = phashTargets.length > 0 ? computePhash(phashTargets) : null;
 
     const skdmHasPkmsg = skdmEncrypted.some(e => e.type === 'pkmsg');
@@ -699,7 +760,7 @@ class MessageSender {
     msgContent.push(new BinaryNode('enc', skmsgAttrs, Buffer.isBuffer(skmsgCiphertext) ? skmsgCiphertext : Buffer.from(skmsgCiphertext)));
 
     const stanzaAttrs = {
-      to: groupJid,
+      to: jidStrToObj(groupJid),
       id: msgId,
       type: mediaType,
       addressing_mode: groupAddressingMode,

package/lib/noise.js

@@ -9,6 +9,7 @@ const { hkdf }     = require('@noble/hashes/hkdf');
 const { MOBILE_PROLOGUE, WHATSAPP_HOST, WHATSAPP_PORT } = require('./constants');
 const { encodeHandshakeClientHello, encodeHandshakeClientFinish,
         decodeServerHello, encodeClientPayload } = require('./proto');
+const { parsePhone, getCountryMeta } = require('./Registration');
 
 // ─── CertChain validator ────────
 //
@@ -282,6 +283,10 @@ class NoiseSocket extends EventEmitter {
       const sharedSS   = dhShared(noisePriv, serverHello.ephemeral);
       this.noiseState.mixKey(sharedSS);
 
+      // Auto-derive MCC/MNC and locale from the registered phone number so the
+      // ClientPayload userAgent is never sent with the telltale '000'/'000' values.
+      const _phoneMeta  = getCountryMeta(parsePhone(this.store.phoneNumber).cc);
+
       const payload = encodeClientPayload({
         username:           BigInt(this.store.phoneNumber),
         passive:            false,
@@ -295,16 +300,16 @@ class NoiseSocket extends EventEmitter {
         userAgent: {
           platform:        (this.store.device && this.store.device.platform) || 1,
           version:         this.store.version,
-          mcc:             '000',
-          mnc:             '000',
+          mcc:             _phoneMeta.mcc,
+          mnc:             _phoneMeta.mnc,
           osVersion:       this.store.device.osVersion,
           manufacturer:    this.store.device.manufacturer,
           device:          this.store.device.model,
           osBuildNumber:   this.store.device.osBuildNumber,
           phoneId:         this.store.fdid.toUpperCase(),
           releaseChannel:  0,
-          localeLanguage:  'en',
-          localeCountry:   'US',
+          localeLanguage:  _phoneMeta.lg,
+          localeCountry:   _phoneMeta.lc,
           deviceType:      0,
           deviceModelType: this.store.device.modelId
         }

package/lib/signal/SignalStore.js

@@ -26,6 +26,7 @@ class SignalStore {
     this._signedPreKeys    = {};
     this._identities       = {};
     this._filePath         = null;
+    this._lidMappings      = {};   // phone → lid — persisted alongside sessions
 
     // Debounce state
     this._dirty            = false;
@@ -56,9 +57,24 @@ class SignalStore {
       this._preKeys       = raw.preKeys       || {};
       this._signedPreKeys = raw.signedPreKeys || {};
       this._identities    = raw.identities    || {};
+      this._lidMappings   = raw.lidMappings   || {};  // phone → lid, persisted
     } catch (_) {}
   }
 
+  // Persist a phone ↔ LID mapping.  Called any time we learn a new mapping from
+  // incoming messages or from a contact usync fallback query.
+  setLidMapping(phone, lid) {
+    if (!phone || !lid) return;
+    if (this._lidMappings[phone] === lid) return; // already stored, skip disk write
+    this._lidMappings[phone] = lid;
+    this._save();
+  }
+
+  // Return all stored phone → lid mappings (used to populate Client._pnToLid on startup)
+  getLidMappings() {
+    return this._lidMappings;
+  }
+
   // Immediate synchronous flush (used on process exit only)
   _flushSync() {
     if (!this._dirty || !this._filePath) return;
@@ -68,7 +84,8 @@ class SignalStore {
         sessions:      this._sessions,
         preKeys:       this._preKeys,
         signedPreKeys: this._signedPreKeys,
-        identities:    this._identities
+        identities:    this._identities,
+        lidMappings:   this._lidMappings
       });
       const dir = path.dirname(this._filePath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -89,7 +106,8 @@ class SignalStore {
         sessions:      this._sessions,
         preKeys:       this._preKeys,
         signedPreKeys: this._signedPreKeys,
-        identities:    this._identities
+        identities:    this._identities,
+        lidMappings:   this._lidMappings
       });
       const dir = path.dirname(this._filePath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });

package/package.json

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