whalibmob 5.10.12 → 5.11.0

package/lib/Client.js

@@ -1968,17 +1968,31 @@ class WhalibmobClient extends EventEmitter {
     const id    = String(attrs.id    || '');
     const ts    = parseInt(attrs.t || '0', 10);
     const participant = String(attrs.participant || from);
-    const senderPn = attrs.sender_pn ? String(attrs.sender_pn) : null;
-    if (senderPn) {
-      const lidUser = from.split('@')[0].split(':')[0];
-      const pnUser  = senderPn.split('@')[0].split(':')[0];
-      if (lidUser && pnUser && lidUser !== pnUser) {
-        this._lidToPn.set(lidUser, pnUser);
-        this._pnToLid.set(pnUser, lidUser);
-        // Persist so the mapping survives reconnects / process restarts
-        if (this._signal && this._signal.store && this._signal.store.setLidMapping) {
-          this._signal.store.setLidMapping(pnUser, lidUser);
-        }
+    const senderPn  = attrs.sender_pn  ? String(attrs.sender_pn)  : null;
+    const senderLid = attrs.sender_lid ? String(attrs.sender_lid) : null;
+
+    // Learn the LID ↔ phone pairing from whichever side the stanza names.
+    //
+    // Decryption needs it: a message addressed by LID has to be able to find a
+    // session filed under the phone JID, and the other way round. The pairing
+    // is only ever visible on a stanza that carries both names, so every such
+    // stanza is worth reading — sender_pn against a LID `from`, and sender_lid
+    // against a phone one.
+    const fromUser = from.split('@')[0].split(':')[0];
+    let learnedLid = null, learnedPn = null;
+    if (senderPn && from.endsWith('@lid')) {
+      learnedLid = fromUser;
+      learnedPn  = senderPn.split('@')[0].split(':')[0];
+    } else if (senderLid && !from.endsWith('@lid')) {
+      learnedPn  = fromUser;
+      learnedLid = senderLid.split('@')[0].split(':')[0];
+    }
+    if (learnedLid && learnedPn && learnedLid !== learnedPn) {
+      this._lidToPn.set(learnedLid, learnedPn);
+      this._pnToLid.set(learnedPn, learnedLid);
+      // Persist so the mapping survives reconnects / process restarts
+      if (this._signal && this._signal.store && this._signal.store.setLidMapping) {
+        this._signal.store.setLidMapping(learnedPn, learnedLid);
       }
     }
     _whaDbg('[DBG] _handleMessage from=' + from + ' participant=' + participant + ' senderPn=' + senderPn + ' id=' + id);
@@ -2050,21 +2064,107 @@ class WhalibmobClient extends EventEmitter {
     this._sendReadReceipt(id, fromRaw, partRaw);
   }
 
+  // The other name this contact answers to, with the device kept.
+  //
+  // A Signal address is user plus device, so the device has to survive the
+  // translation — 250139683860650:5@lid and 40752248147:5@s.whatsapp.net are
+  // the same device, 40752248147:0 is a different one.
+  //
+  // Returns null when there is no mapping for this user yet.
+  _counterpartJid(jid) {
+    if (!jid) return null;
+    const str  = String(jid);
+    const user = str.split('@')[0].split(':')[0];
+    if (!user) return null;
+    const colon  = str.split('@')[0].indexOf(':');
+    const device = colon >= 0 ? str.split('@')[0].slice(colon) : '';
+
+    if (str.endsWith('@lid')) {
+      const pn = this._lidToPn && this._lidToPn.get(user);
+      return pn ? pn + device + '@s.whatsapp.net' : null;
+    }
+    const lid = this._pnToLid && this._pnToLid.get(user);
+    return lid ? lid + device + '@lid' : null;
+  }
+
+  // Every address this message's session might be filed under, best first.
+  _signalJidCandidates(from, participant, senderPn) {
+    const out = [];
+    const add = (jid) => {
+      if (!jid) return;
+      const str = String(jid);
+      if (str && !out.includes(str)) out.push(str);
+    };
+
+    // Unchanged from before: the phone JID the stanza named, or the sender.
+    add(senderPn || ((participant && participant !== from) ? participant : from));
+    // Then the other name for each of them.
+    add(this._counterpartJid(out[0]));
+    add(participant && participant !== from ? participant : null);
+    add(from);
+    add(this._counterpartJid(participant && participant !== from ? participant : from));
+
+    return out;
+  }
+
+  // Try each address in turn and return the first plaintext.
+  //
+  // A failed attempt leaves nothing behind — libsignal either returns the
+  // plaintext or throws, and it only commits the advanced session on success —
+  // so trying the second address after the first misses is safe. The error
+  // reported on total failure is the first one, which is the one about the
+  // address the message actually named.
+  async _decryptWithCandidates(candidates, encType, cipherBuf, id) {
+    let firstErr = null;
+
+    for (let i = 0; i < candidates.length; i++) {
+      try {
+        const plaintext = await this._signal.decrypt(candidates[i], encType, cipherBuf);
+        if (i > 0) {
+          _whaDbg('[DBG] DM_DECRYPT id=' + id + ' recovered under ' + candidates[i] +
+            ' after ' + candidates[0] + ' had no session');
+        }
+        return plaintext;
+      } catch (err) {
+        if (!firstErr) firstErr = err;
+        // Only a missing session is worth asking a different address about.
+        // A session that exists and refuses the ciphertext is a different
+        // problem, and the answer is a retry receipt, not another lookup.
+        if (!/no matching sessions|no session/i.test(String(err && err.message))) break;
+      }
+    }
+
+    throw firstErr || new Error('decrypt: no address to try');
+  }
+
   _decryptDMMessage({ node, from, participant, fromRaw, partRaw, senderPn, id, ts, dmEncNode }) {
     const encType   = dmEncNode.attrs && dmEncNode.attrs.type;
     const cipherBuf = Buffer.isBuffer(dmEncNode.content)
       ? dmEncNode.content
       : Buffer.from(dmEncNode.content || '');
 
-    // WhatsApp LID migration: `from` may be a LID (linked identity) instead of a real phone number
-    // not the phone-based JID. The Signal session is stored under the phone-based JID.
-    // Use sender_pn (phone JID) when available, otherwise fall back to participant/from.
-    const sigJid = senderPn
-      || ((participant && participant !== from) ? participant : from);
+    // The same contact is reachable under two names — a phone JID and a LID —
+    // and a Signal address keeps only the user and the device, never the
+    // domain. So 250139683860650:5@lid and 40752248147:5@s.whatsapp.net are
+    // two different addresses for one person, and a session filed under either
+    // one is invisible from the other.
+    //
+    // Which name a message arrives under is the server's choice and it varies
+    // between messages from the same device. When the session was built under
+    // the phone JID and the next message comes addressed by LID, the lookup
+    // finds nothing and decryption fails with "No matching sessions found for
+    // message" — while the very next message from the same contact decrypts.
+    //
+    // The stanza's own name is tried first, so nothing that already works
+    // changes. The counterpart follows, from the LID↔phone mapping we keep.
+    const candidates = this._signalJidCandidates(from, participant, senderPn);
+    const sigJid     = candidates[0];
 
-    _whaDbg('[DBG] DM_DECRYPT id=' + id + ' type=' + encType + ' sigJid=' + sigJid + ' cipherLen=' + cipherBuf.length);
+    _whaDbg('[DBG] DM_DECRYPT id=' + id + ' type=' + encType + ' sigJid=' + sigJid +
+      (candidates.length > 1 ? ' alts=' + candidates.slice(1).join(',') : '') +
+      ' cipherLen=' + cipherBuf.length);
 
-    this._signal.decrypt(sigJid, encType, cipherBuf)
+    this._decryptWithCandidates(candidates, encType, cipherBuf, id)
       .then(async plaintext => {
         this._resolveRetry(id);
         const decoded = this._decodeMsg(plaintext);

package/package.json

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