whalibmob 2.1.1 → 3.0.0

package/lib/noise.js

@@ -10,6 +10,61 @@ const { MOBILE_PROLOGUE, WHATSAPP_HOST, WHATSAPP_PORT } = require('./constants')
 const { encodeHandshakeClientHello, encodeHandshakeClientFinish,
         decodeServerHello, encodeClientPayload } = require('./proto');
 
+// ─── CertChain validator (matches Baileys WA_CERT_DETAILS.SERIAL = 0) ────────
+//
+// Server payload inside ServerHello is a CertChain protobuf:
+//   CertChain.field2 (intermediate) → NoiseCertificate
+//     NoiseCertificate.field1 (details) → NoiseCertificate.Details
+//       Details.field2 (issuerSerial) must === 0
+//
+// All decoded manually to avoid a protobufjs dependency in noise.js.
+
+function _pbReadVarint(buf, off) {
+  let v = 0, shift = 0;
+  while (off.pos < buf.length) {
+    const b = buf[off.pos++];
+    v |= (b & 0x7f) << shift;
+    if (!(b & 0x80)) break;
+    shift += 7;
+  }
+  return v;
+}
+
+function _pbReadFields(buf) {
+  const fields = {};
+  const off = { pos: 0 };
+  while (off.pos < buf.length) {
+    const tag = _pbReadVarint(buf, off);
+    const fn  = tag >>> 3;
+    const wt  = tag & 7;
+    if (wt === 0) {
+      fields[fn] = _pbReadVarint(buf, off);
+    } else if (wt === 2) {
+      const len = _pbReadVarint(buf, off);
+      fields[fn] = buf.slice(off.pos, off.pos + len);
+      off.pos += len;
+    } else {
+      break; // unexpected wire type — stop parsing
+    }
+  }
+  return fields;
+}
+
+function validateServerCert(payloadBuf) {
+  // payloadBuf is the decrypted ServerHello.payload (CertChain protobuf)
+  const chain        = _pbReadFields(payloadBuf);
+  const intermediate = chain[2]; // field 2 = intermediate NoiseCertificate
+  if (!Buffer.isBuffer(intermediate)) return; // no intermediate cert — skip
+  const cert    = _pbReadFields(intermediate);
+  const details = cert[1]; // field 1 = details bytes
+  if (!Buffer.isBuffer(details)) return;
+  const det          = _pbReadFields(details);
+  const issuerSerial = det[2]; // field 2 = issuerSerial (uint32)
+  if (issuerSerial !== undefined && issuerSerial !== 0) {
+    throw new Error('WA server cert validation failed: issuerSerial=' + issuerSerial + ' expected 0');
+  }
+}
+
 // ─── Curve25519 DH helpers ───────────────────────────────────────────────────
 
 function stripKeyPrefix(pub) {
@@ -216,7 +271,8 @@ class NoiseSocket extends EventEmitter {
       this.noiseState.mixKey(sharedSE);
 
       if (serverHello.payload) {
-        this.noiseState.decryptWithAd(serverHello.payload);
+        const certPlain = this.noiseState.decryptWithAd(serverHello.payload);
+        validateServerCert(certPlain);
       }
 
       const noisePriv  = this.store.noiseKeyPair.private;

package/lib/proto/MessageProto.js

@@ -8,11 +8,13 @@ function tag(fieldNumber, wireType) {
 }
 
 function encodeVarint(n) {
+  // Use Math.floor/% instead of bitwise ops to handle values > 2^31 safely
+  // (JavaScript bitwise ops coerce to Int32, breaking timestamps in ms, large file sizes etc.)
   const bytes = [];
-  let val = n >>> 0;
+  let val = Math.floor(n);
   while (val > 127) {
-    bytes.push((val & 0x7f) | 0x80);
-    val = val >>> 7;
+    bytes.push((val % 128) | 0x80);
+    val = Math.floor(val / 128);
   }
   bytes.push(val);
   return Buffer.from(bytes);
@@ -101,23 +103,25 @@ function encodeVideoMessage(opts) {
     field(9,  WIRE_VARINT, varint(opts.height || 0)),
     field(10, WIRE_VARINT, varint(opts.width  || 0)),
     field(11, WIRE_LEN,    bytes(opts.fileEncSha256)),
-    field(12, WIRE_LEN,    str(opts.directPath)),
-    field(13, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
+    field(13, WIRE_LEN,    str(opts.directPath)),
+    field(14, WIRE_VARINT, varintS(opts.mediaKeyTimestamp || Math.floor(Date.now() / 1000)))
   ];
-  if (opts.jpegThumbnail) parts.push(field(16, WIRE_LEN, bytes(opts.jpegThumbnail)));
   if (opts.gifPlayback)   parts.push(field(8,  WIRE_VARINT, bool(true)));
+  if (opts.jpegThumbnail) parts.push(field(16, WIRE_LEN, bytes(opts.jpegThumbnail)));
   if (opts.contextInfo)   parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
   return Buffer.concat(parts);
 }
 
 function encodeAudioMessage(opts) {
+  // ptt (field 6) goes between seconds (5) and mediaKey (7) — must be in field-number order
+  const pttField = opts.ptt ? field(6, WIRE_VARINT, bool(true)) : Buffer.alloc(0);
   const parts = [
     field(1,  WIRE_LEN,    str(opts.url)),
     field(2,  WIRE_LEN,    str(opts.mimetype || 'audio/ogg; codecs=opus')),
     field(3,  WIRE_LEN,    bytes(opts.fileSha256)),
     field(4,  WIRE_VARINT, varint(opts.fileLength)),
     field(5,  WIRE_VARINT, varint(opts.seconds || 0)),
-    field(6,  WIRE_VARINT, bool(opts.ptt || false)),
+    pttField,
     field(7,  WIRE_LEN,    bytes(opts.mediaKey)),
     field(8,  WIRE_LEN,    bytes(opts.fileEncSha256)),
     field(9,  WIRE_LEN,    str(opts.directPath)),

package/lib/signal/SignalProtocol.js

@@ -11,6 +11,31 @@ const PRE_KEY_COUNT   = 100;
 const PRE_KEY_MIN     = 10;
 const PRE_KEY_START   = 1;
 
+// ─── Per-JID async mutex (matches Baileys encryptionMutex pattern) ────────────
+// Prevents race conditions when two messages are encrypted simultaneously
+// for the same Signal session (e.g. rapid sends or parallel fanout calls).
+
+const _mutexQueues = new Map();
+
+async function _withMutex(key, fn) {
+  // If no queue exists for this key, run immediately
+  if (!_mutexQueues.has(key)) {
+    _mutexQueues.set(key, Promise.resolve());
+  }
+  const prev = _mutexQueues.get(key);
+  let releasePrev;
+  const next = new Promise(r => { releasePrev = r; });
+  _mutexQueues.set(key, next);
+  await prev;
+  try {
+    return await fn();
+  } finally {
+    releasePrev();
+    // Cleanup: if no more waiters, remove from map
+    if (_mutexQueues.get(key) === next) _mutexQueues.delete(key);
+  }
+}
+
 // ─── Padding ──────────────────────────────────────────────────────────────────
 
 function randomPadding() {
@@ -159,14 +184,17 @@ class SignalProtocol {
   // ─── 1-to-1 encrypt / decrypt ─────────────────────────────────────────────
 
   async encrypt(jid, plaintext) {
-    const addr   = jidToAddress(jid);
-    const cipher = new SessionCipher(this.store, addr);
-    const padded = pad(Buffer.from(plaintext));
-    const result = await cipher.encrypt(padded);
-    return {
-      type:       result.type === 3 ? 'pkmsg' : 'msg',
-      ciphertext: Buffer.from(result.body, 'binary')
-    };
+    // Mutex per JID — prevents Signal session race conditions (matches Baileys encryptionMutex)
+    return _withMutex(jid, async () => {
+      const addr   = jidToAddress(jid);
+      const cipher = new SessionCipher(this.store, addr);
+      const padded = pad(Buffer.from(plaintext));
+      const result = await cipher.encrypt(padded);
+      return {
+        type:       result.type === 3 ? 'pkmsg' : 'msg',
+        ciphertext: Buffer.from(result.body, 'binary')
+      };
+    });
   }
 
   async decrypt(jid, type, ciphertext) {
@@ -182,18 +210,17 @@ class SignalProtocol {
   }
 
   // ─── Bulk encrypt for multiple devices (MD fanout) ─────────────────────────
+  // All devices encrypted in parallel (like Baileys Promise.all).
+  // Each JID is protected by its own mutex so parallel calls on the
+  // same JID are still serialized — no Signal session corruption possible.
   // Returns [{jid, type, ciphertext}]
   async bulkEncryptForDevices(jids, plaintext) {
-    const results = [];
-    for (const jid of jids) {
-      try {
-        const enc = await this.encrypt(jid, plaintext);
-        results.push({ jid, type: enc.type, ciphertext: enc.ciphertext });
-      } catch (err) {
-        // Skip devices with no session or errors
-      }
-    }
-    return results;
+    const settled = await Promise.allSettled(
+      jids.map(jid => this.encrypt(jid, plaintext).then(enc => ({ jid, type: enc.type, ciphertext: enc.ciphertext })))
+    );
+    return settled
+      .filter(r => r.status === 'fulfilled')
+      .map(r => r.value);
   }
 
   // ─── SenderKey group encrypt / decrypt ────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "description": "WhatsApp mobile-only Node.js client library with Signal Protocol encryption",
   "main": "index.js",
   "bin": {