whalibmob 5.33.31 → 5.33.33

package/lib/AndroidApk.js

@@ -344,6 +344,26 @@ function extractMaterial(base, splits) {
   const manifest    = parseManifest(readZipEntry(base, entries, 'AndroidManifest.xml'));
   const packageName = manifest.packageName || PERSONAL_PACKAGE;
 
+  // _lh (login integrity_payload): SHA-256 of libwhatsapp.so as it ships in the
+  // APK. On a build with extractNativeLibs=true this is exactly the file
+  // nativeLibraryDir holds, so the hash matches; on a superpack build
+  // (extractNativeLibs=false) the on-device file can differ, which makes this a
+  // best-effort candidate — still better than a pinned constant because it
+  // tracks whichever APK the caller supplied. arm64-v8a is preferred, with the
+  // 32-bit and x86 ABIs as fallbacks, searched across the base APK and splits.
+  let nativeLibSha256 = null;
+  for (const abi of ['arm64-v8a', 'armeabi-v7a', 'x86_64', 'x86']) {
+    const p = 'lib/' + abi + '/libwhatsapp.so';
+    let so = readZipEntry(base, entries, p);
+    if (!so) {
+      for (const split of (splits || [])) {
+        so = readZipEntry(split.data, readZipDirectory(split.data), p);
+        if (so) break;
+      }
+    }
+    if (so) { nativeLibSha256 = crypto.createHash('sha256').update(so).digest(); break; }
+  }
+
   return {
     packageName,
     secretKey:          deriveSecretKey(packageName, aboutLogo),
@@ -357,6 +377,10 @@ function extractMaterial(base, splits) {
     // _gp: the permission-list hash, computed from this APK's own manifest so
     // it tracks the version rather than a pinned constant.
     gpHash:             permissionsHash(manifest.permissions),
+    // _lh: SHA-256 of libwhatsapp.so from the APK (see above); null when no ABI
+    // carries the library, in which case the login integrity_payload falls back
+    // to WA_LH_HASH or the documented candidate.
+    nativeLibSha256,
     certificates,
     // Which drawable the key came from — worth showing, since a bundle carries
     // one per density and only one of them makes the token the server expects.
@@ -460,6 +484,7 @@ function materialToJson(material) {
     apkSha256Full:        material.apkSha256Full       ? material.apkSha256Full.toString('base64')       : null,
     apkSha256First10M:    material.apkSha256First10M   ? material.apkSha256First10M.toString('base64')   : null,
     gpHash:               material.gpHash || null,
+    nativeLibSha256:      material.nativeLibSha256     ? material.nativeLibSha256.toString('base64')     : null,
     certificates:         material.certificates.map(c => c.toString('base64')),
     apkVersion:           material.apkVersion || null,
     apkVersionCode:       material.apkVersionCode || null
@@ -479,6 +504,7 @@ function materialFromJson(json) {
     apkSha256Full:        json.apkSha256Full       ? Buffer.from(json.apkSha256Full, 'base64')       : null,
     apkSha256First10M:    json.apkSha256First10M   ? Buffer.from(json.apkSha256First10M, 'base64')   : null,
     gpHash:               json.gpHash || null,
+    nativeLibSha256:      json.nativeLibSha256     ? Buffer.from(json.nativeLibSha256, 'base64')     : null,
     certificates:         json.certificates.map(c => Buffer.from(c, 'base64')),
     apkVersion:           json.apkVersion || null,
     apkVersionCode:       json.apkVersionCode || null

package/lib/Attestation.js

@@ -66,15 +66,23 @@ function generateGeToken() {
 // ─── _ga: app analytics envelope ─────────────────────────────────────────────
 // bi    AES-256-CBC (key = SHA256(standard base64 of the auth key), random IV
 //       prepended) over the base64 of 32 random bytes: 88 base64 characters
-// ap    age of base.apk in seconds
-// ai    age of the oldest file in the data directory
+// ap    age of base.apk in seconds — the install is hours to days old and
+//       independent of (always older than) ai: a real phone had the app long
+//       before it re-registered
+// ai    age of the oldest file in the data directory — the session's own setup,
+//       minutes to several hours
 // ae    age of the oldest file in the external files directory, a little
-//       younger than ai
+//       younger than ai (tens of seconds to ~30 minutes)
 // mp/mu monkey-test flags, false on a device a person is using
 //
 // The ages model a fresh install, drawn per request: fixed numbers would be
 // the same on every registration this library makes, which no phone does.
-function generateGaToken(authKeyRaw) {
+// The inner JSON object of _ga, without percent-encoding. Shared between the
+// registration _ga parameter (which percent-encodes this) and the login
+// integrity_payload (which embeds the object verbatim). The slashes inside `bi`
+// are escaped here; the integrity_payload builder escapes its other values
+// around this fragment and leaves bi as-is, matching the live blob.
+function buildGaInner(authKeyRaw) {
   const aesKey    = sha256(Buffer.from(authKeyRaw.toString('base64'), 'utf8'));
   const plaintext = Buffer.from(crypto.randomBytes(32).toString('base64'), 'utf8');
   const iv        = crypto.randomBytes(16);
@@ -82,12 +90,18 @@ function generateGaToken(authKeyRaw) {
   const ct        = Buffer.concat([cipher.update(plaintext), cipher.final()]);
   const bi        = Buffer.concat([iv, ct]).toString('base64').replace(/\//g, '\\/');
 
-  const ai = 120 + crypto.randomInt(7081);                    // 2 min .. 2 h
-  const ap = Math.max(1, ai + crypto.randomInt(601) - 300);   // ai ± 5 min
-  const ae = ai - (30 + crypto.randomInt(91));                // ai − 30..120 s
+  // A live client was observed sending ap≈4 days ≫ ai≈5.5 h > ae (ai − ~26 min).
+  // The earlier model made ap≈ai, which no real install shows: base.apk predates
+  // the data directory by far more than a few minutes.
+  const ai = 600 + crypto.randomInt(28800);                   // 10 min .. 8 h
+  const ap = ai + 3600 + crypto.randomInt(864000);            // ai + 1 h .. +10 d
+  const ae = Math.max(1, ai - (30 + crypto.randomInt(1771))); // ai − 30 s .. 30 min
 
-  const json = '{"bi":"' + bi + '","ap":' + ap + ',"ai":' + ai + ',"mp":false,"ae":' + ae + ',"mu":false}';
-  return encodeURIComponent(json);
+  return '{"bi":"' + bi + '","ap":' + ap + ',"ai":' + ai + ',"mp":false,"ae":' + ae + ',"mu":false}';
+}
+
+function generateGaToken(authKeyRaw) {
+  return encodeURIComponent(buildGaInner(authKeyRaw));
 }
 
 function generateGsToken() {
@@ -157,14 +171,41 @@ function generateGgToken(authKeyRaw, icCode, itToken) {
 // ─── _gp: SHA-256 of the manifest permission list ────────────────────────────
 // Base64 SHA-256 of the sorted, separator-less permission names, percent-encoded
 // on the wire. Computed from the installed APK's own manifest (material.gpHash)
-// so it tracks the version. The constant is the known value for 2.26.35.75+ on
-// Android 12+ (85 permissions) and is used when no material hash is available —
-// an older material file, or a build read without the manifest permissions.
-const GP_ANDROID12 = 'XpccAx8EKQswlTL2MtpCnGIMXTCaUbAf95ElLECc6jk=';
+// so it tracks the version — that is always preferred when a real APK is loaded.
+// When no material hash is available (a headless run, or a build read without
+// the manifest permissions), WA_GP_HASH overrides the fallback for a specific
+// version, and otherwise GP_DEFAULT is sent: the value a live current client was
+// observed sending. The previous known value for 2.26.35.75+ on Android 12
+// (85 permissions) was 'XpccAx8EKQswlTL2MtpCnGIMXTCaUbAf95ElLECc6jk='.
+const GP_DEFAULT = 'q19gmaQaITVtyoBCdLsD7CiZKryGA9zltE8yTd30NdI=';
+
+function gpHashValue(material) {
+  return (material && material.gpHash) ||
+    (process.env.WA_GP_HASH && process.env.WA_GP_HASH.trim()) ||
+    GP_DEFAULT;
+}
 
 function generateGpToken(material) {
-  const hash = (material && material.gpHash) || GP_ANDROID12;
-  return encodeURIComponent(hash);
+  return encodeURIComponent(gpHashValue(material));
+}
+
+// ─── _lh: hash of the native library from nativeLibraryDir ────────────────────
+// _lh = base64(SHA-256(<nativeLibraryDir>/libwhatsapp.so)). It appears only
+// inside the login integrity_payload (never in the registration _gi), new in
+// 2.26.37.73. A headless client has no nativeLibraryDir to read — modern builds
+// ship the libraries in the superpack and leave that directory empty — so the
+// exact on-device file cannot be observed here. The value is taken, in order,
+// from the extracted APK material (AndroidApk hashes libwhatsapp.so out of the
+// APK, which matches the device on extractNativeLibs=true builds and is the best
+// candidate otherwise), the WA_LH_HASH override, or the documented per-version
+// candidate for libwhatsapp.so (2.26.35.75). This mirrors how _gp falls back
+// when no manifest hash is available.
+const LH_DEFAULT = 'euEs+17faTS6Mt7WHjzn7spB95xywNpuimy0sWbyuME=';
+
+function lhHashValue(material) {
+  const m = material && material.nativeLibSha256;
+  if (m) return Buffer.isBuffer(m) ? m.toString('base64') : m;
+  return (process.env.WA_LH_HASH && process.env.WA_LH_HASH.trim()) || LH_DEFAULT;
 }
 
 // ─── _gi: installation integrity ─────────────────────────────────────────────
@@ -220,6 +261,62 @@ function generateGiToken(authKeyRaw, material, install) {
   return integrityEnvelope(authKeyRaw, json);
 }
 
+// ─── Post-login integrity_payload ─────────────────────────────────────────────
+// The blob the client hands over in <ib><integrity_payload> after the first
+// login, in response to the server's <ib><safetynet><integrity nonce='…'>. It is
+// the same AES-256-CBC envelope as the registration _gi (key
+// SHA256(std-base64(authkey)), IV‖ciphertext, PKCS7), but the plaintext JSON has
+// a fixed, wider key order and nests _ge and _ga as objects rather than as the
+// separate percent-encoded parameters they are at registration:
+//
+//   aid, _dh, _lh, _iln, _ln, _ge, _gp, _ga, _ip, _isb, _n, _icr, _is
+//
+// _n echoes the server's safetynet nonce in plaintext inside the envelope, which
+// binds the blob to the request. The result is standard base64 (not URL-safe,
+// not percent-encoded): it is the text content of the <integrity_payload> node.
+//
+// Returns null when the material/identity needed to build a faithful blob is
+// missing, so the caller sends nothing rather than a half-formed envelope.
+function generateIntegrityPayload(opts) {
+  opts = opts || {};
+  const { material, aid, serverNonce } = opts;
+  const authKeyRaw = (Buffer.isBuffer(opts.authKeyRaw) && opts.authKeyRaw.length === 32)
+    ? opts.authKeyRaw : null;
+  if (!authKeyRaw || !aid || !serverNonce) return null;
+  if (!material || !material.classesDexSha256 || material.apkSize == null ||
+      !material.apkSha256Full || !material.certificates || !material.certificates.length) {
+    return null;
+  }
+  const pkg = material.packageName || 'com.whatsapp';
+  const iln = GI_ILN[pkg];
+  if (!iln) return null;
+
+  const esc = (s) => String(s).replace(/\//g, '\\/');
+  const b64 = (buf) => esc(buf.toString('base64'));
+
+  const json = '{' +
+    '"aid":"'  + esc(aid)                        + '",' +
+    '"_dh":"'  + b64(material.classesDexSha256)  + '",' +
+    '"_lh":"'  + esc(lhHashValue(material))      + '",' +
+    '"_iln":"' + esc(iln)                        + '",' +
+    '"_ln":"'  + esc(GI_LN)                      + '",' +
+    '"_ge":'   + '{"sb":false,"sv":false}'       + ',' +
+    '"_gp":"'  + esc(gpHashValue(material))      + '",' +
+    '"_ga":'   + buildGaInner(authKeyRaw)        + ',' +
+    '"_ip":"'  + esc(pkg)                        + '",' +
+    '"_isb":"' + String(material.apkSize)        + '",' +
+    '"_n":"'   + esc(serverNonce)                + '",' +
+    '"_icr":"' + b64(crypto.createHash('sha1').update(material.certificates[0]).digest()) + '",' +
+    '"_is":"'  + b64(material.apkSha256Full)     + '"' +
+  '}';
+
+  const aesKey = sha256(Buffer.from(authKeyRaw.toString('base64'), 'utf8'));
+  const iv     = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', aesKey, iv);
+  const ct     = Buffer.concat([cipher.update(Buffer.from(json, 'utf8')), cipher.final()]);
+  return Buffer.concat([iv, ct]).toString('base64');
+}
+
 // ─── Empty (NONE) fallbacks ───────────────────────────────────────────────────
 
 const EMPTY_ANDROID = { gpia: '', gg: '', gi: '', gp: '', ge: '', ga: '' };
@@ -422,6 +519,7 @@ module.exports = {
   attestBody,
   androidInfo,
   generateGaToken,
+  generateIntegrityPayload,
   toHex,
   toBase64Url,
   EMPTY_ANDROID,

package/lib/Client.js

@@ -1702,6 +1702,15 @@ class WhalibmobClient extends EventEmitter {
 
     this._parseSuccessNode(successNode);
 
+    // The successful-login counter (ClientPayload field 24, lc) advances: the
+    // value just announced in the handshake was the pre-login count, and this
+    // login is now accepted. Wraps to 0 past int32 max, as the reference does.
+    {
+      const next = (this._store.connectionLc || 0) + 1;
+      this._store.connectionLc = next > 0x7fffffff ? 0 : next;
+      this._persistStore();
+    }
+
     // ── Feature 3 (part A): Send <active> IQ ─────────────────────────────────
     // WhatsApp opens sessions as "passive" — the client must explicitly
     // activate the connection before the server will deliver messages.
@@ -1741,6 +1750,14 @@ class WhalibmobClient extends EventEmitter {
         _whaDbg('[DBG] AB_PROPS_FETCH_FAILED ' + (err && err.message)));
     }
 
+    // First login only: check the terms-of-service notice the app checks right
+    // after its first <success>. A fresh account is already accepted
+    // server-side, so this is a quiet confirmation, not a prompt — but a client
+    // that never asks is one more way the session reads as not the app.
+    if (!this._hasConnectedOnce) {
+      this._acceptLoginTos();
+    }
+
     // ── Reconnect: flush stale device cache + background re-usync ─────────────
     // On first connect _hasConnectedOnce is false — nothing extra to do.
     // On every reconnect (network drop / NAT reset / server restart) we flush the
@@ -1916,9 +1933,57 @@ class WhalibmobClient extends EventEmitter {
       this._sendAppStateSyncForTypes(dirtyTypes);
     }
 
+    // After the first login the server asks for a SafetyNet attestation with
+    // <ib><safetynet><integrity nonce='…'/></safetynet></ib>. The client answers
+    // in the same window with <ib><integrity_payload> (and a keystore chain that
+    // needs a real TEE, which a headless client cannot produce). We send the
+    // integrity_payload leg, which is the same AES envelope as the registration
+    // _gi and so is reproducible here.
+    for (const child of children) {
+      if (!child || child.description !== 'safetynet') continue;
+      const integ = Array.isArray(child.content)
+        ? child.content.find(c => c && c.description === 'integrity')
+        : null;
+      const nonce = integ && integ.attrs && integ.attrs.nonce;
+      if (nonce) this._sendIntegrityPayload(String(nonce));
+    }
+
     this.emit('ib', { node });
   }
 
+  // Build and send <ib><integrity_payload> in response to the server's SafetyNet
+  // nonce. Opt-in through WA_INTEGRITY_PAYLOAD: the envelope is faithful, but the
+  // native-library hash (_lh) cannot be read on a headless client, so the blob
+  // carries a best-known value and is sent only when asked for. Android only,
+  // and only when the APK material needed to fill the blob is present.
+  _sendIntegrityPayload(nonce) {
+    try {
+      if (!process.env.WA_INTEGRITY_PAYLOAD || !this._socket) return;
+      const device = this._store.device;
+      if (!device || device.os !== 'android') return;
+
+      const Registration = require('./Registration');
+      const attestation  = require('./Attestation');
+      const material = Registration.tryLoadAndroidMaterial(device);
+      if (!material) return;
+
+      const blob = attestation.generateIntegrityPayload({
+        authKeyRaw:  stripKeyPrefix(this._store.noiseKeyPair.public),
+        material,
+        aid:         Registration._verify.deviceAid(this._store),
+        serverNonce: nonce
+      });
+      if (!blob) return;
+
+      this._socket.sendNode(new BinaryNode('ib', {}, [
+        new BinaryNode('integrity_payload', {}, blob)
+      ]));
+      _whaDbg('[DBG] INTEGRITY_PAYLOAD sent (' + blob.length + ' b64 chars)');
+    } catch (err) {
+      _whaDbg('[DBG] INTEGRITY_PAYLOAD failed: ' + (err && err.message));
+    }
+  }
+
   // ── Feature 3 (part C): Send an app-state-sync IQ ──────────────────────────
   //
   // Maps WhatsApp dirty-type names → the actual collection names used in the
@@ -7252,6 +7317,26 @@ class WhalibmobClient extends EventEmitter {
    *          `refresh` is how many seconds the server suggests waiting before
    *          asking again.
    */
+  // The notice the native client checks on its first login — the general WhatsApp
+  // terms. Captured post-<success> as <iq xmlns='tos' type='get'><request>
+  // <notice id='20210210'/></request>.
+  static get FIRST_LOGIN_TOS_NOTICE() { return '20210210'; }
+
+  // Fire-and-forget first-login terms check. Queries the standard notice and, if
+  // the server reports it outstanding, accepts it. Every failure is swallowed:
+  // the account works whether or not this round-trip lands, exactly as the other
+  // on-connect syncs do.
+  _acceptLoginTos() {
+    const notice = WhalibmobClient.FIRST_LOGIN_TOS_NOTICE;
+    this.queryTosNotices([notice])
+      .then((parsed) => {
+        const outstanding = parsed.notices.filter(n => !n.accepted).map(n => n.id);
+        if (outstanding.length) return this.acceptTosNotices(outstanding);
+      })
+      .then(() => _whaDbg('[DBG] TOS first-login check done'))
+      .catch(err => _whaDbg('[DBG] TOS first-login check failed: ' + (err && err.message)));
+  }
+
   async queryTosNotices(noticeIds) {
     if (!this._connected) throw new Error('Not connected');
     if (!Array.isArray(noticeIds)) throw new Error('queryTosNotices: noticeIds must be an array');

package/lib/DeviceConfig.js

@@ -73,6 +73,10 @@ function getDeviceConfig() {
       osVersion:       process.env.WA_DEVICE_OS_VERSION   || '14',
       osBuildNumber:   process.env.WA_DEVICE_BUILD        || 'UP1A.231005.007',
       modelId:         process.env.WA_DEVICE_MODEL_ID     || 'SM-S928B',
+      // Build.BOARD, announced as userAgent field 13 when set. Left unset by
+      // default: the native client omits the field when the board is empty, so a
+      // guessed value would be worse than none.
+      board:           process.env.WA_DEVICE_BOARD        || undefined,
       // What the handset reports as usable RAM, in GiB. Registration sends it,
       // and it has to belong to the handset beside it — see deviceRam().
       ram:             process.env.WA_DEVICE_RAM          || '11.55',

package/lib/Registration.js

@@ -1244,7 +1244,7 @@ function toUrlHex(buf) {
 
 // The native client inserts registration fields into a LinkedHashMap in a
 // fixed order; the wire sequence is that insertion order, not a sort. These are
-// the live orders captured from WhatsApp Android (WA_REVERSE_2026): 50 fields
+// the live orders captured from WhatsApp Android reverse engerring: 50 fields
 // for /v2/code, 49 for /v2/register. gpia/token/vname that this build omits
 // simply drop out — their slots collapse.
 const CODE_PARAM_ORDER = [
@@ -2704,7 +2704,7 @@ module.exports._verify = {
   hasChallenge, is2FARequired, decodeOrNull, isSuccessful,
   normalizeCodeResult, currentVerifyScreen, adoptCanonicalNumber, funnelEnabled, waitHint,
   flashCodeFromCallerId, flashCodeLength, applyFlashFilter, codeForSubmission,
-  getRequestVerificationCodeParameters, getRegisterDeviceParameters, getInstallIdentity
+  getRequestVerificationCodeParameters, getRegisterDeviceParameters, getInstallIdentity, deviceAid
 };
 
 // Pacing internals, exposed for tests. Not part of the public API.

package/lib/Store.js

@@ -116,6 +116,7 @@ function createNewStore(phoneNumber, opts) {
     backupToken,
     registered:    false,
     codePending:   false,  // true after /code request, cleared on successful /register
+    connectionLc:  0,      // successful-login counter (ClientPayload field 24)
     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
@@ -218,6 +219,10 @@ function storeToJson(store) {
     // separate commands, so both are written down rather than drawn again.
     accessSessionId: store._accessSessionId || null,
     gaToken:         store._gaToken || null,
+    // Successful-login counter (ClientPayload field 24, lc). Starts at 0 on
+    // registration and increments after each accepted <success>, so the number
+    // the account logs in with grows the way a real install's does.
+    connectionLc:    store.connectionLc || 0,
     // Firebase identity behind the push_token. Google issues an android id once
     // and expects it back; discarding it would mint a new phantom device on
     // every registration step, which is worse than carrying one.
@@ -277,6 +282,9 @@ function storeFromJson(obj) {
     codeMethod:     obj.codeMethod || null,
     _accessSessionId: obj.accessSessionId || undefined,
     _gaToken:         obj.gaToken || undefined,
+    // Absent on stores written before the counter existed; 0 is the same value
+    // a fresh registration starts from.
+    connectionLc:     obj.connectionLc || 0,
     // Absent on stores written before push tokens existed; null simply means
     // the first registration step will fetch one.
     fcm:            obj.fcm || null,

package/lib/noise.js

@@ -182,6 +182,37 @@ const CONNECT_TYPE_WIFI               = 1;  // WIFI_UNKNOWN
 const CONNECT_REASON_USER_ACTIVATED   = 1;
 const DEVICE_TYPE_PHONE               = 0;
 
+// ClientPayload yearClass (field 36) and memClass (field 37): stationary device
+// performance classes the native client derives from RAM/CPU and caches once per
+// install. The server expects them on every login and watches for jumps as a
+// device-change signal, so they are derived from the declared RAM (reported
+// GiB, below nominal) to stay stable for a given profile. The native yearClass
+// also folds in CPU frequency and core count; with only RAM at hand the RAM rows
+// of the 2016 scale are used, which decide the class for all but the oldest
+// hardware. memClass mirrors ActivityManager.getMemoryClass() — the per-app heap
+// in MiB the platform assigns by RAM tier.
+function yearClassFromRam(ramGiB) {
+  const bytes = Number(ramGiB) * 1073741824;
+  if (!Number.isFinite(bytes) || bytes <= 0) return 2015;
+  if (bytes <=  805306368) return 2010;   // ≤ 768 MiB
+  if (bytes <= 1073741824) return 2012;   // ≤ 1 GiB
+  if (bytes <= 1610612736) return 2013;   // ≤ 1.5 GiB
+  if (bytes <= 2147483648) return 2013;   // ≤ 2 GiB
+  if (bytes <= 3221225472) return 2014;   // ≤ 3 GiB
+  if (bytes <= 5368709120) return 2015;   // ≤ 5 GiB
+  return 2016;                            // > 5 GiB
+}
+
+function memClassFromRam(ramGiB) {
+  const g = Number(ramGiB);
+  if (!Number.isFinite(g) || g <= 0) return 256;
+  if (g < 1) return 48;
+  if (g < 2) return 96;
+  if (g < 3) return 128;
+  if (g < 4) return 192;
+  return 256;
+}
+
 // ─── Curve25519 DH helpers ───────────────────────────────────────────────────
 
 function stripKeyPrefix(pub) {
@@ -596,6 +627,23 @@ class NoiseSocket extends EventEmitter {
         connectAttemptCount: (this.store.connectAttemptCount || 0),
         device:             0,
         oc:                 false,
+        // A real client always sends these. sessionId is a per-login-attempt
+        // int; lc is the successful-login counter persisted on the store (0 on
+        // the first login, incremented after each <success>); yearClass/memClass
+        // are the device performance classes, stable for this profile.
+        sessionId:          crypto.randomBytes(4).readUInt32BE(0) & 0x7fffffff,
+        lc:                 (this.store.connectionLc || 0),
+        yearClass:          yearClassFromRam(_device.ram),
+        memClass:           memClassFromRam(_device.ram),
+        // The remaining fields a real client always writes. dnsSource reports
+        // how the chat host was resolved (SYSTEM by default, or SOCKS_PROXY when
+        // a proxy transport is in use); trafficAnonymization is OFF unless the
+        // account enabled it; connectionSequenceInfo packs the port and host
+        // category — port 443 (1) and the primary host (1<<2) give 5 on a direct
+        // first connect.
+        dnsSource:          { dnsMethod: require('./socks').socksProxyUrl() ? 7 : 0, appCached: false },
+        trafficAnonymization: 0,
+        connectionSequenceInfo: 5,
         userAgent: {
           // Which client this says it is. The server checks the announced
           // version against *this* platform, so a wrong number here comes back
@@ -635,6 +683,14 @@ class NoiseSocket extends EventEmitter {
           releaseChannel:  0,
           localeLanguage:  _phoneMeta.lg,
           localeCountry:   _phoneMeta.lc,
+          // Build.BOARD (14→13): sent only when the profile carries one, as the
+          // native client does. deviceExpId (14) is the installation expid
+          // lowercased — the same value registration sends as `expid` — which
+          // the native client always writes.
+          deviceBoard:     _device.board || undefined,
+          deviceExpId:     this.store.deviceId
+            ? this.store.deviceId.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '').toLowerCase()
+            : undefined,
           // DeviceType enum (field 15): PHONE. Every profile shipped here is a
           // phone — the numeric `deviceModelType` on the profiles is unrelated
           // to this and is read by nothing.

package/lib/proto.js

@@ -33,7 +33,7 @@ function encodeVersion(major, minor, patch, q) {
   return Buffer.concat(parts);
 }
 
-function encodeUserAgent({ platform, version, mcc, mnc, osVersion, manufacturer, device, osBuildNumber, phoneId, releaseChannel, localeLanguage, localeCountry, deviceType, deviceModelType }) {
+function encodeUserAgent({ platform, version, mcc, mnc, osVersion, manufacturer, device, osBuildNumber, phoneId, releaseChannel, localeLanguage, localeCountry, deviceBoard, deviceExpId, deviceType, deviceModelType }) {
   const versionBuf = encodeVersion(...version.split('.').map(Number));
   const parts = [
     field(1, VARINT, varint(platform)),
@@ -49,12 +49,27 @@ function encodeUserAgent({ platform, version, mcc, mnc, osVersion, manufacturer,
   parts.push(field(10, VARINT, varint(releaseChannel || 0)));
   parts.push(field(11, LEN, string(localeLanguage || 'en')));
   parts.push(field(12, LEN, string(localeCountry || 'US')));
+  // Build.BOARD (13) — only when the profile carries one, matching the native
+  // client, which sets it only if the string is non-empty.
+  if (deviceBoard) parts.push(field(13, LEN, string(deviceBoard)));
+  // deviceExpId (14) — the installation expid, lowercased. The native client
+  // always writes it (the value may be empty), so it is sent unconditionally.
+  if (deviceExpId !== undefined) parts.push(field(14, LEN, string(deviceExpId)));
   if (deviceType !== undefined) parts.push(field(15, VARINT, varint(deviceType)));
   if (deviceModelType) parts.push(field(16, LEN, string(deviceModelType)));
   return Buffer.concat(parts);
 }
 
-function encodeClientPayload({ username, passive, userAgent, pushName, shortConnect, connectType, connectReason, connectAttemptCount, device, oc }) {
+// dnsSource (ClientPayload field 15, message C1J4): field 15 dnsMethod (enum),
+// field 16 appCached (bool). The inner message reuses the numbers 15/16 — that
+// is how the native schema is laid out.
+function encodeDnsSource({ dnsMethod, appCached }) {
+  const parts = [field(15, VARINT, varint(dnsMethod || 0))];
+  if (appCached !== undefined) parts.push(field(16, VARINT, bool(appCached)));
+  return Buffer.concat(parts);
+}
+
+function encodeClientPayload({ username, passive, userAgent, pushName, sessionId, shortConnect, connectType, connectReason, dnsSource, connectAttemptCount, device, oc, lc, yearClass, memClass, trafficAnonymization, connectionSequenceInfo }) {
   const uaBuf = encodeUserAgent(userAgent);
   const parts = [
     field(1, VARINT, varint(username)),
@@ -62,12 +77,19 @@ function encodeClientPayload({ username, passive, userAgent, pushName, shortConn
     field(5, LEN, bytes(uaBuf))
   ];
   if (pushName) parts.push(field(7, LEN, string(pushName)));
+  if (sessionId !== undefined) parts.push(field(9, VARINT, varint(sessionId)));
   if (shortConnect !== undefined) parts.push(field(10, VARINT, bool(shortConnect)));
   if (connectType !== undefined) parts.push(field(12, VARINT, varint(connectType)));
   if (connectReason !== undefined) parts.push(field(13, VARINT, varint(connectReason)));
+  if (dnsSource !== undefined) parts.push(field(15, LEN, bytes(encodeDnsSource(dnsSource))));
   if (connectAttemptCount !== undefined) parts.push(field(16, VARINT, varint(connectAttemptCount)));
   if (device !== undefined) parts.push(field(18, VARINT, varint(device)));
   if (oc !== undefined) parts.push(field(23, VARINT, bool(oc)));
+  if (lc !== undefined) parts.push(field(24, VARINT, varint(lc)));
+  if (yearClass !== undefined) parts.push(field(36, VARINT, varint(yearClass)));
+  if (memClass !== undefined) parts.push(field(37, VARINT, varint(memClass)));
+  if (trafficAnonymization !== undefined) parts.push(field(40, VARINT, varint(trafficAnonymization)));
+  if (connectionSequenceInfo !== undefined) parts.push(field(43, VARINT, varint(connectionSequenceInfo)));
   return Buffer.concat(parts);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.33.31",
+  "version": "5.33.33",
   "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",