whalibmob 5.10.12 → 5.11.1

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/lib/Registration.js

@@ -136,51 +136,144 @@ async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader) {
     `Content-Length: ${Buffer.byteLength(body)}`
   ];
   if (authHeader) reqLines.push(`Authorization: ${authHeader}`);
-  // close, not keep-alive: the response is read by waiting for the server to
-  // end the stream. Asking it to keep the connection open means that never
-  // happens and the request hangs until something else times out.
+  // Asked for, but not relied on: the server answers and then keeps the
+  // connection open anyway. The response is finished by its own length, not by
+  // the socket closing.
   reqLines.push(`Connection: close`, '', body);
   const req = reqLines.join('\r\n');
 
   tlsSocket.write(req);
 
-  const chunks = [];
-  await new Promise((res, rej) => {
+  const { status, body: bodyBuf } = await readHttpResponse(tlsSocket, path);
+  const bodyStr = bodyBuf.toString('utf8');
+
+  if (status !== 200) throw new Error(`HTTP ${status} ${path}: ${bodyStr}`);
+  try { return JSON.parse(bodyStr); } catch (_) { return { raw: bodyStr }; }
+}
+
+// A response is over when its own length says so, not when the socket shuts.
+//
+// This is the part `https.request` does for you and a hand-rolled socket does
+// not. WhatsApp answers a registration request in well under a second and then
+// leaves the connection open — `Connection: close` in the request does not
+// change that. Waiting for end or close therefore waited for something that
+// never came, and every proxied registration died on the read timeout with the
+// reply already sitting in the buffer.
+//
+// So: parse as the bytes arrive, and stop at the end of the body — the byte
+// count in Content-Length, or the terminating zero-length chunk. end and close
+// stay as a fallback, for a reply that declares neither and can only be
+// delimited by the connection itself.
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+
+function readHttpResponse(socket, label, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let raw    = Buffer.alloc(0);
+    let done   = false;
+
     const timer = setTimeout(() => {
-      tlsSocket.destroy();
-      rej(new Error('SOCKS proxy timed out reading ' + path));
-    }, 30000);
-    const finish = (fn, arg) => { clearTimeout(timer); fn(arg); };
-    tlsSocket.on('data',  d  => chunks.push(d));
-    tlsSocket.on('end',   () => finish(res));
-    tlsSocket.on('close', () => finish(res));
-    tlsSocket.on('error', e  => finish(rej, e));
+      settle(reject, new Error('SOCKS proxy timed out reading ' + label));
+    }, timeoutMs || 30000);
+
+    function settle(fn, arg) {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.removeListener('data',  onData);
+      socket.removeListener('end',   onEnd);
+      socket.removeListener('close', onEnd);
+      socket.removeListener('error', onError);
+      socket.destroy();
+      fn(arg);
+    }
+
+    function onData(chunk) {
+      raw = raw.length ? Buffer.concat([raw, chunk]) : chunk;
+      if (raw.length > MAX_RESPONSE_BYTES) {
+        return settle(reject, new Error('response too large reading ' + label));
+      }
+      const parsed = parseHttpResponse(raw, false);
+      if (parsed) settle(resolve, parsed);
+    }
+
+    // The connection did close after all — then whatever arrived is the whole
+    // reply, even without a declared length.
+    function onEnd() {
+      const parsed = parseHttpResponse(raw, true);
+      if (parsed) return settle(resolve, parsed);
+      settle(reject, new Error('connection closed mid-response reading ' + label));
+    }
+
+    function onError(err) { settle(reject, err); }
+
+    socket.on('data',  onData);
+    socket.on('end',   onEnd);
+    socket.on('close', onEnd);
+    socket.on('error', onError);
   });
+}
+
+/**
+ * Parse what has arrived so far.
+ *
+ * Returns { status, headers, body } once the response is complete, or null
+ * while it is still short. With `atEof` the caller is telling us no more bytes
+ * are coming, which is itself a valid way for a body to end.
+ */
+function parseHttpResponse(raw, atEof) {
+  const headerEnd = raw.indexOf('\r\n\r\n');
+  if (headerEnd < 0) return null;
+
+  // Headers are latin1 by definition; only the body may be UTF-8.
+  const headers   = raw.slice(0, headerEnd).toString('latin1');
+  const status    = parseInt(headers.split(' ')[1], 10);
+  const bodyStart = headerEnd + 4;
+
+  if (/^transfer-encoding:[ \t]*chunked/im.test(headers)) {
+    const decoded = decodeChunkedBody(raw.slice(bodyStart));
+    if (decoded) return { status, headers, body: decoded };
+    return atEof ? { status, headers, body: Buffer.alloc(0) } : null;
+  }
 
-  const raw        = Buffer.concat(chunks);
-  const rawStr     = raw.toString('utf8');
-  const headerEnd  = rawStr.indexOf('\r\n\r\n');
-  const headerPart = rawStr.slice(0, headerEnd);
-  const httpStatus = parseInt(rawStr.split(' ')[1]);
-  let bodyStr      = rawStr.slice(headerEnd + 4);
-
-  // Handle chunked transfer encoding
-  if (/transfer-encoding:\s*chunked/i.test(headerPart)) {
-    let decoded = '';
-    let pos = 0;
-    while (pos < bodyStr.length) {
-      const lineEnd = bodyStr.indexOf('\r\n', pos);
-      if (lineEnd === -1) break;
-      const chunkSize = parseInt(bodyStr.slice(pos, lineEnd), 16);
-      if (!chunkSize) break;
-      decoded += bodyStr.slice(lineEnd + 2, lineEnd + 2 + chunkSize);
-      pos = lineEnd + 2 + chunkSize + 2;
+  const match = /^content-length:[ \t]*(\d+)/im.exec(headers);
+  if (match) {
+    const length = parseInt(match[1], 10);
+    // Counted in bytes, which is why this works on the buffer and not on a
+    // decoded string — one accented character in an error message is two bytes
+    // and would leave the check one short forever.
+    if (raw.length - bodyStart >= length) {
+      return { status, headers, body: raw.slice(bodyStart, bodyStart + length) };
     }
-    bodyStr = decoded;
+    return atEof ? { status, headers, body: raw.slice(bodyStart) } : null;
   }
 
-  if (httpStatus !== 200) throw new Error(`HTTP ${httpStatus} ${path}: ${bodyStr}`);
-  try { return JSON.parse(bodyStr); } catch (_) { return { raw: bodyStr }; }
+  // These two carry no body at all, whatever else the headers say.
+  if (status === 204 || status === 304) {
+    return { status, headers, body: Buffer.alloc(0) };
+  }
+
+  // No length anywhere: the body runs to the end of the connection.
+  return atEof ? { status, headers, body: raw.slice(bodyStart) } : null;
+}
+
+/** Decode a chunked body, or null while the terminating chunk is still missing. */
+function decodeChunkedBody(buf) {
+  const parts = [];
+  let pos = 0;
+
+  for (;;) {
+    const lineEnd = buf.indexOf('\r\n', pos);
+    if (lineEnd < 0) return null;
+    // A size line may carry extensions after a semicolon; parseInt stops there.
+    const size = parseInt(buf.slice(pos, lineEnd).toString('latin1'), 16);
+    if (!Number.isFinite(size) || size < 0) return null;
+    if (size === 0) return Buffer.concat(parts);      // the terminating chunk
+    const start = lineEnd + 2;
+    const end   = start + size;
+    if (buf.length < end + 2) return null;            // chunk still arriving
+    parts.push(buf.slice(start, end));
+    pos = end + 2;
+  }
 }
 const {
   REGISTRATION_ENDPOINT,
@@ -953,3 +1046,6 @@ async function verifyCode(store, code) {
 }
 
 module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, parsePhone, getCountryMeta, assertRegistrationKeys, parseSocksProxy, socksProxyUrl };
+
+// The HTTP reader, exposed for tests. Not part of the public API.
+module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody };

package/package.json

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