whalibmob 5.29.2 → 5.29.4

package/lib/DeviceManager.js

@@ -1206,57 +1206,123 @@ class DeviceManager {
    * and sends both hashes on the same notification — so each is verified on its
    * own, and one going wrong does not cost the other.
    *
-   * @param   {string} cacheKey     the cache entry: digits, or 'lid:<user>'
-   * @param   {string} user         the JID user part the ids belong to
-   * @param   {Array<{tag: string, deviceId: number}>} changes
-   * @param   {string} serverHash   device_hash, or device_lid_hash
-   * @param   {string} [server]     's.whatsapp.net' (default) or 'lid'
-   * @returns {boolean} whether the result verified and the cache was kept
+   * The steps are applied one at a time, and each is checked against its own
+   * hash: `device_hash` describes the list **after that change**, not after the
+   * notification as a whole. A contact linking two devices in one sitting sends
+   * two children with two different hashes, and reading them as one change with
+   * one hash — which is what this did — meant the notification could never
+   * verify and the cache was dropped every time. Stepping through them the way
+   * whatsmeow's handleDeviceNotification does keeps the cache across exactly
+   * the case that used to defeat it.
+   *
+   * A step that fails to verify drops the cache but not the running list, so a
+   * later step whose hash does match puts a proven list back — the same
+   * recovery whatsmeow gets from mutating its local copy after deleting the
+   * cached one.
+   *
+   * @param   {object} opts
+   * @param   {string} opts.priKey     the cache entry: digits, or 'lid:<user>'
+   * @param   {string} opts.priUser    the JID user part the ids belong to
+   * @param   {string} [opts.priServer] 's.whatsapp.net' (default) or 'lid'
+   * @param   {string} [opts.lidKey]   cache entry for the LID half, when known
+   * @param   {string} [opts.lidUser]  the LID user part
+   * @param   {Array}  opts.steps      from Client._parseDeviceDelta
+   * @returns {{primaryOk: boolean, lidOk: boolean}} which halves ended verified
    */
-  verifyDeviceDelta(cacheKey, user, changes, serverHash, server) {
-    server = server || 's.whatsapp.net';
-    if (!cacheKey || !user || !serverHash) return false;
-    if (!Array.isArray(changes) || !changes.length) return false;
+  applyDeviceDelta(opts) {
+    opts = opts || {};
+    const priKey    = opts.priKey;
+    const priUser   = opts.priUser;
+    const priServer = opts.priServer || 's.whatsapp.net';
+    const steps     = opts.steps;
+    const out       = { primaryOk: false, lidOk: false };
+
+    if (!priKey || !priUser) return out;
+    if (!Array.isArray(steps) || !steps.length) return out;
 
     // No baseline means there is nothing to apply a change to. Caching just the
     // one device named in the notification would make a list of one look
     // authoritative, which is how a recipient's other devices stop being
     // written to.
-    const cached = this._dcGet(cacheKey);
-    if (!cached || !cached.length) return false;
-
-    const next = new Set(cached);
-    for (const { tag, deviceId } of changes) {
-      if (!Number.isFinite(deviceId)) return false;
-      if (tag === 'add')         next.add(deviceId);
-      else if (tag === 'remove') next.delete(deviceId);
-      else return false;   // 'update' and anything unknown: do not guess
+    const cached = this._dcGet(priKey);
+    if (!cached || !cached.length) return out;
+
+    const haveLid = !!(opts.lidKey && opts.lidUser);
+    const pri = new Set(cached);
+    // The LID half starts from whatever is on file, empty included. It cannot
+    // go wrong the way the primary half could: a list built from nothing has to
+    // pass the server's hash before it is written anywhere.
+    const lid = haveLid ? new Set(this._dcGet(opts.lidKey) || []) : null;
+
+    for (const step of steps) {
+      if (!step) continue;
+
+      // `update` does not say what changed. The list on file cannot be trusted
+      // and cannot be repaired, so it goes — and the remaining steps still get
+      // their turn, as they do in whatsmeow.
+      if (step.tag === 'update') {
+        this._dcDel([priKey]);
+        out.primaryOk = false;
+        _whaDbg('[DBG] DEV_HASH update for ' + priKey + ' — cache dropped');
+        continue;
+      }
+      if (step.tag !== 'add' && step.tag !== 'remove') continue;
+      if (!Number.isFinite(step.deviceId) || !step.hash) continue;
+
+      if (step.tag === 'add') pri.add(step.deviceId);
+      else                    pri.delete(step.deviceId);
+
+      const ids  = [...pri].sort((a, b) => a - b);
+      const ours = this._phashOfDevices(priUser, ids, priServer);
+      if (ours && ours === step.hash) {
+        this._dcSet(priKey, ids);
+        out.primaryOk = true;
+        _whaDbg('[DBG] DEV_HASH verified for ' + priKey + ' ids=[' + ids.join(',') +
+          '] hash=' + ours);
+      } else {
+        this._dcDel([priKey]);
+        out.primaryOk = false;
+        _whaDbg('[DBG] DEV_HASH mismatch for ' + priKey + ' ours=' + ours +
+          ' server=' + step.hash + ' — dropping cache');
+      }
+
+      // The LID half of the same change, checked on its own. The server hashes
+      // the two lists separately and one going wrong does not cost the other.
+      if (!haveLid || step.lidDeviceId === null || !step.lidHash) continue;
+
+      if (step.tag === 'add') lid.add(step.lidDeviceId);
+      else                    lid.delete(step.lidDeviceId);
+
+      const lidIds  = [...lid].sort((a, b) => a - b);
+      const lidOurs = this._phashOfDevices(opts.lidUser, lidIds, 'lid');
+      if (lidOurs && lidOurs === step.lidHash) {
+        this._dcSet(opts.lidKey, lidIds);
+        out.lidOk = true;
+        _whaDbg('[DBG] DEV_HASH verified for ' + opts.lidKey + ' ids=[' +
+          lidIds.join(',') + '] hash=' + lidOurs);
+      } else {
+        this._dcDel([opts.lidKey]);
+        out.lidOk = false;
+        _whaDbg('[DBG] DEV_HASH mismatch for ' + opts.lidKey + ' ours=' + lidOurs +
+          ' server=' + step.lidHash + ' — dropping cache');
+      }
     }
 
-    const ids  = [...next].sort((a, b) => a - b);
-    const jids = ids.map(d => makeDeviceJid(user, d, server));
+    return out;
+  }
 
-    let ours;
+  // The participant hash of one user's device ids, or null when it cannot be
+  // computed. Same function the group fan-out and the server both use, which is
+  // the whole reason the comparison above means anything.
+  _phashOfDevices(user, deviceIds, server) {
     try {
       // Lazily required: MessageSender requires this file, so taking it at the
       // top would close the cycle before either module finishes loading.
       const { computePhash } = require('./messages/MessageSender');
-      ours = computePhash(jids);
+      return computePhash(deviceIds.map(d => makeDeviceJid(user, d, server)));
     } catch (_) {
-      return false;
-    }
-
-    if (ours !== String(serverHash)) {
-      _whaDbg('[DBG] DEV_HASH mismatch for ' + cacheKey + ' ours=' + ours +
-        ' server=' + serverHash + ' — dropping cache');
-      this._dcDel([cacheKey]);
-      return false;
+      return null;
     }
-
-    this._dcSet(cacheKey, ids);
-    _whaDbg('[DBG] DEV_HASH verified for ' + cacheKey + ' ids=[' + ids.join(',') +
-      '] hash=' + ours);
-    return true;
   }
 
   clearCache(phones) {

package/lib/MediaService.js

@@ -229,10 +229,6 @@ function _tryUpload(host, mediaPath, token, auth, encrypted, web) {
   });
 }
 
-// opts.fileEncSha256, when given, is checked against the blob as it arrived.
-// The MAC inside decryptMedia already proves the plaintext was not tampered
-// with, but this catches a truncated or substituted download before spending
-// the work on it, and tells the two failures apart.
 // Where a message's media actually lives. Most carry an absolute `url`, but a
 // message that arrived through history sync often has only the `directPath`,
 // which is that URL with the CDN host taken off the front.
@@ -245,19 +241,72 @@ function resolveMediaUrl(url, directPath) {
   return 'https://' + CDN_HOST + (p.startsWith('/') ? '' : '/') + p;
 }
 
+// Compare a digest against what the message said it should be. Returns null
+// when it matches or when there is nothing to compare against, and the reason
+// when it does not.
+function _digestMismatch(actual, expected, what) {
+  if (!expected || !expected.length) return null;
+  const want = Buffer.from(expected);
+  // timingSafeEqual throws on a length mismatch rather than returning false.
+  if (want.length !== actual.length) return what + ' is the wrong length';
+  return crypto.timingSafeEqual(actual, want) ? null : what + ' mismatch';
+}
+
+/**
+ * Download one media file and decrypt it.
+ *
+ * Three things are checked, and all three are checked by default — the message
+ * says what the file should be, so there is no reason to take the CDN's word
+ * for it:
+ *
+ *   fileEncSha256   the blob as it arrived off the CDN
+ *   the MAC         inside decryptMedia, the one that actually authenticates
+ *   fileSha256      the plaintext, after decrypting
+ *
+ * The MAC is the guarantee — its key comes from the mediaKey, which only the
+ * sender and the recipients hold — and it was always checked. The two digests
+ * were not: fileEncSha256 only when the caller asked for it, and fileSha256
+ * never at all, though it was written on every upload. whatsmeow checks both on
+ * every download (ErrInvalidMediaSHA256), and now so does this.
+ *
+ * They tell failures apart, too. A truncated or substituted download is caught
+ * before any work is spent decrypting it, and a plaintext that decrypts but is
+ * not the file the message described is a different fault from a corrupt blob.
+ *
+ * @param {object} [opts]
+ * @param {Buffer} [opts.fileEncSha256] digest of the encrypted blob
+ * @param {Buffer} [opts.fileSha256]    digest of the decrypted file
+ * @param {boolean} [opts.verify=true]  pass false to skip both digest checks;
+ *                                      the MAC is always checked either way
+ */
 async function downloadMedia(url, mediaKey, keyName, opts) {
+  opts = opts || {};
+  const check     = opts.verify !== false;
   const encrypted = await _httpGet(url, opts);
-  const expected  = opts && opts.fileEncSha256;
-  if (expected && expected.length) {
-    const actual = crypto.createHash('sha256').update(encrypted).digest();
-    const want   = Buffer.from(expected);
-    // timingSafeEqual throws on a length mismatch rather than returning false.
-    if (want.length !== actual.length || !crypto.timingSafeEqual(actual, want)) {
-      throw new Error('downloadMedia: the downloaded file does not match the message ' +
-        '(fileEncSha256 mismatch)');
+
+  if (check) {
+    const bad = _digestMismatch(
+      crypto.createHash('sha256').update(encrypted).digest(),
+      opts.fileEncSha256, 'fileEncSha256');
+    if (bad) {
+      throw new Error('downloadMedia: the downloaded file does not match the ' +
+        'message (' + bad + ')');
+    }
+  }
+
+  const plaintext = decryptMedia(encrypted, Buffer.from(mediaKey), keyName);
+
+  if (check) {
+    const bad = _digestMismatch(
+      crypto.createHash('sha256').update(plaintext).digest(),
+      opts.fileSha256, 'fileSha256');
+    if (bad) {
+      throw new Error('downloadMedia: the decrypted file is not the one the ' +
+        'message described (' + bad + ')');
     }
   }
-  return decryptMedia(encrypted, Buffer.from(mediaKey), keyName);
+
+  return plaintext;
 }
 
 // The CDN applies the same Origin check on the way down as on the way up, so a
@@ -307,11 +356,26 @@ function _httpGet(url, opts, depth) {
   });
 }
 
+// A thumbnail is encrypted under a key name of its own, not under the key name
+// of the message that carries it. The one in use is the link-preview thumbnail
+// on an extendedTextMessage — it has its own directPath and its own digests
+// beside the message's, and reading it with 'WhatsApp Image Keys' produces a
+// MAC failure and nothing else. There is no upload path because nothing here
+// uploads one; they arrive with a link preview the sender built.
+const THUMBNAIL_KEY_NAME = {
+  extendedText: 'WhatsApp Link Thumbnail Keys',
+  text:         'WhatsApp Link Thumbnail Keys'
+};
+
 function getMediaKeyName(mediaType) {
   const typeInfo = MEDIA_PATH[mediaType];
   return typeInfo ? typeInfo.keyName : null;
 }
 
+function getThumbnailKeyName(mediaType) {
+  return THUMBNAIL_KEY_NAME[mediaType] || null;
+}
+
 module.exports = {
   MEDIA_PATH,
   encryptMedia,
@@ -323,5 +387,6 @@ module.exports = {
   httpGetBuffer: _httpGet,
   deriveMediaKeyData,
   getMediaKeyName,
+  getThumbnailKeyName,
   resolveMediaUrl
 };

package/lib/Registration.js

@@ -478,8 +478,32 @@ const COUNTRY_META = {
   '998':   { mcc: '434', mnc: '03', lg: 'ru', lc: 'UZ' }, // Uzbekistan (UzMobile)
 };
 
-function getCountryMeta(cc) {
-  return COUNTRY_META[cc] || { mcc: '000', mnc: '000', lg: 'en', lc: 'US' };
+// The carrier metadata for a country calling code.
+//
+// The table names one operator per country — Romania is always Orange, Brazil
+// always Vivo — because that is the best a table keyed by calling code can do.
+// It cannot be better: number portability means the prefix stopped naming the
+// operator years ago, so guessing from the number would be wrong more often
+// than the table is.
+//
+// So the caller can say instead. Whoever is registering knows which SIM is in
+// the phone, and sim_mcc/sim_mnc are meant to describe that SIM; WA_SIM_MCC and
+// WA_SIM_MNC (or `simMcc`/`simMnc` in the options) override the guess with the
+// truth. The language and locale stay with the country either way.
+//
+// MNC keeps whatever width it is given: 226/10 and 226/010 are different
+// networks to the server, and normalising them would break one of the two.
+function getCountryMeta(cc, opts) {
+  const base = COUNTRY_META[cc] || { mcc: '000', mnc: '000', lg: 'en', lc: 'US' };
+
+  const mcc = (opts && opts.simMcc) || process.env.WA_SIM_MCC;
+  const mnc = (opts && opts.simMnc) || process.env.WA_SIM_MNC;
+  if (!mcc && !mnc) return base;
+
+  const out = Object.assign({}, base);
+  if (mcc) out.mcc = String(mcc).trim();
+  if (mnc) out.mnc = String(mnc).trim();
+  return out;
 }
 
 // ---------- Phone number parsing ----------
@@ -1201,6 +1225,57 @@ function waitHint(response, method) {
   return retry > 0 ? retry : null;
 }
 
+// ---------- device_ram ----------
+//
+// What the handset reports as usable RAM, in GiB, from
+// ActivityManager.MemoryInfo.totalMem — which is always below the nominal
+// figure on the box, because the kernel, the GPU and the secure world reserve a
+// slice before Android ever sees it. A 12 GB phone reports around 11.5.
+//
+// This was the constant 3.57 on every request, while the same payload declared
+// a Galaxy S24 Ultra beside it. There is no such handset: the S24 Ultra ships
+// with 12 GB and no variant of it has ever had 3.57. Two fields of one request
+// describing two different phones is not a fingerprint worth defending — it is
+// simply wrong, in the way a wrong `os_version` would be. It now comes off the
+// declared profile, so whichever handset the caller says they are on, the
+// memory belongs to it.
+const DEFAULT_DEVICE_RAM = '5.62';
+
+function deviceRam(device) {
+  const ram = device && device.ram;
+  if (ram == null) return DEFAULT_DEVICE_RAM;
+  const n = Number(ram);
+  // Two decimals, the way the client formats it.
+  return Number.isFinite(n) && n > 0 ? n.toFixed(2) : DEFAULT_DEVICE_RAM;
+}
+
+// ---------- pid ----------
+//
+// The process id of the app making the request.
+//
+// This sent `process.pid` — the Node process. Inside a container that is 1, and
+// pid 1 on Android is `init`; no application process is ever 1. Elsewhere it is
+// whatever the host happened to hand out, which is as likely to be 7 as 24000.
+//
+// Android hands out pids from a counter that starts near 300 and wraps at
+// /proc/sys/kernel/pid_max, 32768 by default, so an app launched on a phone
+// that has been up any length of time lands well inside that range. One is
+// derived per store here, from the same identity material everything else in
+// the payload comes from — deterministic on purpose, because /exist, /code and
+// /register are three requests from one running app and a process does not
+// change its pid between them. Restoring a saved session keeps the pid it had,
+// for the same reason.
+function getAppPid(store) {
+  if (store._appPid) return store._appPid;
+  const seed = (store.identityId && Buffer.isBuffer(store.identityId))
+    ? store.identityId
+    : Buffer.from(String(store.phoneNumber || ''), 'utf8');
+  const h = crypto.createHash('sha256').update(seed).update('pid').digest();
+  // 1024..32767 — clear of the kernel and early-boot range, inside pid_max.
+  store._appPid = String(1024 + (h.readUInt32BE(0) % (32768 - 1024)));
+  return store._appPid;
+}
+
 function buildClientMetrics(attempt) {
   const json = '{"attempts":' + (attempt || 1)
     + ',"app_campaign_download_source":"google-play|unknown"'
@@ -1250,9 +1325,9 @@ function getRequestVerificationCodeParameters(store, method, meta, device, attem
       'advertising_id',             store.advertisingId || '',
       'hasinrc',                    '1',
       'roaming_type',               '0',
-      'device_ram',                 '3.57',
+      'device_ram',                 deviceRam(device),
       'education_screen_displayed', 'true',
-      'pid',                        String(process.pid),
+      'pid',                        getAppPid(store),
       'cellular_strength',          '5',
       'backup_token',               store.backupToken ? toUrlHex(store.backupToken) : '',
       'tos_version',                '5',
@@ -1354,7 +1429,7 @@ function buildVerifiedNameCertificate(store, device) {
 
 async function buildPayload(store, waVersion, useToken, extraPairs) {
   const { cc, national } = parsePhone(store.phoneNumber);
-  const meta   = getCountryMeta(cc);
+  const meta   = getCountryMeta(cc, store);
   const device = store.device || getDeviceConfig();
   const token  = useToken ? computeToken(waVersion, national, device) : null;
   // Android formats fdid lowercase, iOS uppercase (matches the native clients).
@@ -1826,7 +1901,7 @@ async function checkNumberStatus(phoneNumber) {
   const store     = createNewStore(phoneNumber);
   const waVersion = await fetchWaVersion(_device);
   const { cc }    = parsePhone(phoneNumber);
-  const meta      = getCountryMeta(cc);
+  const meta      = getCountryMeta(cc, store);
 
   function hasBlock(r) {
     return r && !!r.custom_block_screen;
@@ -1988,7 +2063,7 @@ async function requestSmsCode(store, method, opts) {
 
   // Derive real MCC/MNC from the phone number being registered.
   const { cc: _regCc } = parsePhone(store.phoneNumber);
-  const _regMeta       = getCountryMeta(_regCc);
+  const _regMeta       = getCountryMeta(_regCc, store);
 
   async function _tryMethod(m) {
     // Retry loop:

package/lib/Store.js

@@ -113,6 +113,12 @@ function createNewStore(phoneNumber, opts) {
     registered:    false,
     codePending:   false,  // true after /code request, cleared on successful /register
     name:          normalizePushName(opts.name) || 'User',
+    // Which SIM is actually in the phone. The country table can only guess one
+    // operator per calling code — number portability broke the prefix→operator
+    // link long ago — so whoever is registering can name theirs instead. Null
+    // leaves the table's guess in place. See getCountryMeta in Registration.js.
+    simMcc:        opts.simMcc ? String(opts.simMcc).trim() : null,
+    simMnc:        opts.simMnc ? String(opts.simMnc).trim() : null,
     version,
     device,
     // ADVSignedDeviceIdentity bytes received from server <success> node.
@@ -194,6 +200,8 @@ function storeToJson(store) {
     advertisingId:  store.advertisingId || null,
     backupToken:    store.backupToken ? store.backupToken.toString('base64') : null,
     registered:     !!store.registered,
+    simMcc:         store.simMcc || null,
+    simMnc:         store.simMnc || null,
     codePending:    store.codePending || false,
     // Which delivery method the pending code actually went out by. The two
     // registration steps are normally separate commands, so the confirmation
@@ -246,6 +254,10 @@ function storeFromJson(obj) {
     advertisingId:  obj.advertisingId || uuidv4(),
     backupToken:    obj.backupToken ? Buffer.from(obj.backupToken, 'base64') : crypto.randomBytes(20),
     registered:     !!obj.registered,
+    // Null on stores written before the SIM could be declared, which simply
+    // means the country table's guess stands.
+    simMcc:         obj.simMcc || null,
+    simMnc:         obj.simMnc || null,
     codePending:    obj.codePending || false,
     codeMethod:     obj.codeMethod || null,
     // Absent on stores written before push tokens existed; null simply means

package/lib/constants.js

@@ -169,91 +169,91 @@ const ANDROID_DEVICE_PROFILES = {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Samsung Galaxy S24 Ultra', manufacturer: 'Samsung',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'SM-S928B', deviceModelType: 2
+    modelId: 'SM-S928B', deviceModelType: 2, ram: '11.55'
   },
   'samsung-s24': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Samsung Galaxy S24', manufacturer: 'Samsung',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'SM-S921B', deviceModelType: 2
+    modelId: 'SM-S921B', deviceModelType: 2, ram: '7.63'
   },
   'samsung-s23': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Samsung Galaxy S23', manufacturer: 'Samsung',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'SM-S911B', deviceModelType: 2
+    modelId: 'SM-S911B', deviceModelType: 2, ram: '7.63'
   },
   'samsung-s23-ultra': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Samsung Galaxy S23 Ultra', manufacturer: 'Samsung',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'SM-S918B', deviceModelType: 2
+    modelId: 'SM-S918B', deviceModelType: 2, ram: '11.55'
   },
   'samsung-a55': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Samsung Galaxy A55', manufacturer: 'Samsung',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'SM-A556B', deviceModelType: 1
+    modelId: 'SM-A556B', deviceModelType: 1, ram: '7.44'
   },
   'pixel8pro': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Pixel 8 Pro', manufacturer: 'Google',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'Pixel 8 Pro', deviceModelType: 2
+    modelId: 'Pixel 8 Pro', deviceModelType: 2, ram: '11.44'
   },
   'pixel8': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Pixel 8', manufacturer: 'Google',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'Pixel 8', deviceModelType: 2
+    modelId: 'Pixel 8', deviceModelType: 2, ram: '7.53'
   },
   'pixel7': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Pixel 7', manufacturer: 'Google',
     osVersion: '14', osBuildNumber: 'TP1A.221005.002',
-    modelId: 'Pixel 7', deviceModelType: 2
+    modelId: 'Pixel 7', deviceModelType: 2, ram: '7.53'
   },
   'pixel7a': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Pixel 7a', manufacturer: 'Google',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'Pixel 7a', deviceModelType: 1
+    modelId: 'Pixel 7a', deviceModelType: 1, ram: '7.44'
   },
   'xiaomi14': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Xiaomi 14', manufacturer: 'Xiaomi',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: '23127PN0CG', deviceModelType: 2
+    modelId: '23127PN0CG', deviceModelType: 2, ram: '11.36'
   },
   'xiaomi13': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'Xiaomi 13', manufacturer: 'Xiaomi',
     osVersion: '13', osBuildNumber: 'TQ3A.230901.001',
-    modelId: '2211133G', deviceModelType: 2
+    modelId: '2211133G', deviceModelType: 2, ram: '7.51'
   },
   'oneplus12': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'OnePlus 12', manufacturer: 'OnePlus',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'CPH2573', deviceModelType: 2
+    modelId: 'CPH2573', deviceModelType: 2, ram: '11.48'
   },
   'oneplus11': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'OnePlus 11', manufacturer: 'OnePlus',
     osVersion: '13', osBuildNumber: 'TQ3A.230901.001',
-    modelId: 'CPH2449', deviceModelType: 2
+    modelId: 'CPH2449', deviceModelType: 2, ram: '15.32'
   },
   'oppo-find-x7': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'OPPO Find X7', manufacturer: 'OPPO',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'CPH2599', deviceModelType: 2
+    modelId: 'CPH2599', deviceModelType: 2, ram: '11.40'
   },
   'realme-gt5': {
     os: 'android', platform: PLATFORM.ANDROID,
     model: 'realme GT 5 Pro', manufacturer: 'realme',
     osVersion: '14', osBuildNumber: 'UP1A.231005.007',
-    modelId: 'RMX3888', deviceModelType: 2
+    modelId: 'RMX3888', deviceModelType: 2, ram: '15.28'
   }
 };
 

package/lib/proto/MessageProto.js

@@ -794,11 +794,47 @@ function decodeMessageContainer(buf, depth) {
     }
 
     // Field 6: extendedTextMessage — field 1 = text
+    //
+    // A text message with a link in it comes as one of these, and everything
+    // the sender's client built for the preview rides along: the title and
+    // description it scraped, and a thumbnail. The thumbnail is a media file of
+    // its own — its own directPath, its own digests, its own mediaKey — not a
+    // part of the message, which is why only the inline jpegThumbnail was ever
+    // reachable and the full-size one could not be fetched at all.
+    //
+    //   text=1 matchedText=2 description=5 title=6 jpegThumbnail=16
+    //   thumbnailDirectPath=19 thumbnailSha256=20 thumbnailEncSha256=21
+    //   mediaKey=22
     if (!msgResult && f[6] && Buffer.isBuffer(f[6])) {
       try {
-        const ext = _decodeFields(f[6]);
+        const ext  = _decodeFields(f[6]);
         const text = _str(ext[1]);
-        if (text) msgResult = { type: 'text', text };
+        if (text) {
+          msgResult = { type: 'text', text };
+
+          const matchedText = _str(ext[2]);
+          const description = _str(ext[5]);
+          const title       = _str(ext[6]);
+          if (matchedText) msgResult.matchedText = matchedText;
+          if (description) msgResult.description = description;
+          if (title)       msgResult.title       = title;
+          if (Buffer.isBuffer(ext[16]) && ext[16].length) {
+            msgResult.jpegThumbnail = ext[16];
+          }
+
+          // The downloadable preview image, when the sender attached one. All
+          // four are needed together: without the key it cannot be decrypted,
+          // and without the digests it cannot be checked.
+          const thumbPath = _str(ext[19]);
+          if (thumbPath && Buffer.isBuffer(ext[22]) && ext[22].length) {
+            msgResult.thumbnail = {
+              directPath:        thumbPath,
+              mediaKey:          ext[22],
+              thumbnailSha256:    Buffer.isBuffer(ext[20]) ? ext[20] : null,
+              thumbnailEncSha256: Buffer.isBuffer(ext[21]) ? ext[21] : null
+            };
+          }
+        }
       } catch (_) {}
     }
 
@@ -1044,9 +1080,42 @@ function decodeMessageContainer(buf, depth) {
       } catch (_) { msgResult = { type: 'poll', question: '', options: [] }; }
     }
 
-    // Field 50: pollUpdateMessage (a vote on an existing poll)
+    // Field 50: pollUpdateMessage — somebody voted on a poll.
+    //
+    //   PollUpdateMessage { pollCreationMessageKey=1, vote=2,
+    //                       senderTimestampMs=3 }
+    //   MessageKey        { remoteJid=1, fromMe=2, id=3 }
+    //   PollEncValue      { encPayload=1, encIV=2 }
+    //
+    // The vote itself is encrypted under a key derived from the poll's message
+    // secret, so the ballot cannot be read from the stanza alone — see
+    // decryptPollVote. Every one of these decoded to the bare word 'pollVote'
+    // and nothing else, which left no way to tell which poll had been voted on,
+    // let alone what the vote was.
     if (!msgResult && f[50] && Buffer.isBuffer(f[50])) {
       msgResult = { type: 'pollVote' };
+      try {
+        const upd = _decodeFields(f[50]);
+
+        if (Buffer.isBuffer(upd[1])) {
+          const key = _decodeFields(upd[1]);
+          msgResult.pollKey = {
+            remoteJid: _str(key[1]) || null,
+            fromMe:    !!key[2],
+            id:        _str(key[3]) || null
+          };
+        }
+
+        if (Buffer.isBuffer(upd[2])) {
+          const vote = _decodeFields(upd[2]);
+          if (Buffer.isBuffer(vote[1]) && Buffer.isBuffer(vote[2])) {
+            msgResult.encPayload = vote[1];
+            msgResult.encIv      = vote[2];
+          }
+        }
+
+        if (typeof upd[3] === 'number') msgResult.senderTimestampMs = upd[3];
+      } catch (_) { /* the bare type is still worth reporting */ }
     }
 
     // If we found a real message, attach skdmInfo / messageSecret and return.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.29.2",
+  "version": "5.29.4",
   "description": "Node.js library for WhatsApp — register a number over SMS, or link as a companion by QR. Signal E2E encryption, media, groups, channels.",
   "author": "Kunboruto20",
   "main": "index.js",