whalibmob 5.33.23 → 5.33.28

package/README.md

@@ -45,7 +45,7 @@ code, and bring the account into being. Both transports, one API.
 > wa registration --request-code <number> --method wa_old
 > wa registration --register   <number> --code <code>
 > ```
->
+> 
 > **This is optional.** Most numbers register fine with `--method sms` or `--method voice` — try those first. Use the `wa_old` route **only if** you want a guaranteed, 100% success rate on numbers where SMS/voice are blocked.
 
 ##
@@ -6171,4 +6171,5 @@ The **Sponsor** button at the top of the repository leads back here.
 
 ## License
 
-MIT
+MIT     
+.

package/lib/AndroidApk.js

@@ -215,12 +215,14 @@ function _readStringPool(buf, pos) {
 }
 
 /**
- * { packageName, versionName, versionCode } out of a binary AndroidManifest.xml.
- * Any field the manifest does not carry comes back null.
+ * { packageName, versionName, versionCode, permissions } out of a binary
+ * AndroidManifest.xml. Any field the manifest does not carry comes back null,
+ * and permissions is the list of every <uses-permission> /
+ * <uses-permission-sdk-23> name, in manifest order (the _gp hash sorts them).
  */
 function parseManifest(buf) {
-  const empty = { packageName: null, versionName: null, versionCode: null };
-  if (!buf || buf.length < 8) return empty;
+  const out = { packageName: null, versionName: null, versionCode: null, permissions: [] };
+  if (!buf || buf.length < 8) return out;
 
   let strings = null;
   let pos = 8;                                     // past the file's own chunk header
@@ -238,32 +240,37 @@ function parseManifest(buf) {
       const attributeStart = buf.readUInt16LE(ext + 8);
       const attributeSize  = buf.readUInt16LE(ext + 10);
       const attributeCount = buf.readUInt16LE(ext + 12);
-      if (strings[nameIndex] !== 'manifest') { pos += chunkSize; continue; }
-
-      const out = Object.assign({}, empty);
-      for (let i = 0; i < attributeCount; i++) {
-        const a        = ext + attributeStart + i * attributeSize;
-        const attrName = strings[buf.readUInt32LE(a + 4)];
-        const rawValue = buf.readUInt32LE(a + 8);
-        const dataType = buf[a + 15];
-        const data     = buf.readUInt32LE(a + 16);
-        // A string attribute names its value in the pool twice — the raw source
-        // text and the typed value. Either will do; the raw one is absent when
-        // the manifest was written without it.
-        const asString = () =>
-          (rawValue !== 0xffffffff && strings[rawValue] !== undefined) ? strings[rawValue]
-          : (dataType === _TYPE_STRING ? strings[data] : String(data));
-
-        if (attrName === 'package')      out.packageName = asString();
-        else if (attrName === 'versionName') out.versionName = asString();
-        else if (attrName === 'versionCode') out.versionCode = dataType === _TYPE_STRING
-          ? parseInt(strings[data], 10) : data;
+      const elementName    = strings[nameIndex];
+
+      const attr = (wantName) => {
+        for (let i = 0; i < attributeCount; i++) {
+          const a        = ext + attributeStart + i * attributeSize;
+          if (strings[buf.readUInt32LE(a + 4)] !== wantName) continue;
+          const rawValue = buf.readUInt32LE(a + 8);
+          const dataType = buf[a + 15];
+          const data     = buf.readUInt32LE(a + 16);
+          // A string attribute names its value in the pool twice — the raw
+          // source text and the typed value. Either will do; the raw one is
+          // absent when the manifest was written without it.
+          return (rawValue !== 0xffffffff && strings[rawValue] !== undefined) ? strings[rawValue]
+            : (dataType === _TYPE_STRING ? strings[data] : String(data));
+        }
+        return null;
+      };
+
+      if (elementName === 'manifest') {
+        out.packageName = attr('package');
+        out.versionName = attr('versionName');
+        const vc = attr('versionCode');
+        out.versionCode = vc == null ? null : (/^\d+$/.test(vc) ? parseInt(vc, 10) : vc);
+      } else if (elementName === 'uses-permission' || elementName === 'uses-permission-sdk-23') {
+        const name = attr('name');
+        if (name) out.permissions.push(name);
       }
-      return out;
     }
     pos += chunkSize;
   }
-  return empty;
+  return out;
 }
 
 // A split's own name, as Android files it: "config.xxhdpi" out of
@@ -339,8 +346,17 @@ function extractMaterial(base, splits) {
 
   return {
     packageName,
-    secretKey:     deriveSecretKey(packageName, aboutLogo),
-    classesDexMd5: crypto.createHash('md5').update(classesDex).digest(),
+    secretKey:          deriveSecretKey(packageName, aboutLogo),
+    classesDexMd5:      crypto.createHash('md5').update(classesDex).digest(),
+    // What _gi reports about the installed base.apk: the dex, the whole file,
+    // its first 10 MiB and its size.
+    classesDexSha256:   crypto.createHash('sha256').update(classesDex).digest(),
+    apkSize:            base.length,
+    apkSha256Full:      crypto.createHash('sha256').update(base).digest(),
+    apkSha256First10M:  crypto.createHash('sha256').update(base.subarray(0, 0xA00000)).digest(),
+    // _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),
     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.
@@ -352,6 +368,25 @@ function extractMaterial(base, splits) {
   };
 }
 
+// The _gp value: base64 SHA-256 of the sorted, separator-less concatenation of
+// the requested permission names, as PackageManager.getRequestedPermissions()
+// hands them to the app. On Android 12+ the platform drops the legacy
+// android.permission.BLUETOOTH when BLUETOOTH_CONNECT is present, so the hash
+// matches the device only once that one name is removed. Returns null when the
+// manifest carried no permissions (nothing to hash).
+const _PERM_BLUETOOTH         = 'android.permission.BLUETOOTH';
+const _PERM_BLUETOOTH_CONNECT = 'android.permission.BLUETOOTH_CONNECT';
+
+function permissionsHash(permissions) {
+  if (!Array.isArray(permissions) || !permissions.length) return null;
+  let names = permissions.slice();
+  if (names.includes(_PERM_BLUETOOTH_CONNECT)) {
+    names = names.filter(n => n !== _PERM_BLUETOOTH);
+  }
+  names.sort();
+  return crypto.createHash('sha256').update(Buffer.from(names.join(''), 'utf8')).digest('base64');
+}
+
 // PBKDF2-HMAC-SHA1 over the package name followed by the raw PNG bytes.
 //
 // A JCA factory rejects a binary password, so a hand-rolled loop is the usual
@@ -417,12 +452,17 @@ function looksLikeWhatsAppCertificate(description) {
 
 function materialToJson(material) {
   return {
-    packageName:    material.packageName,
-    secretKey:      material.secretKey.toString('base64'),
-    classesDexMd5:  material.classesDexMd5.toString('base64'),
-    certificates:   material.certificates.map(c => c.toString('base64')),
-    apkVersion:     material.apkVersion || null,
-    apkVersionCode: material.apkVersionCode || null
+    packageName:          material.packageName,
+    secretKey:            material.secretKey.toString('base64'),
+    classesDexMd5:        material.classesDexMd5.toString('base64'),
+    classesDexSha256:     material.classesDexSha256   ? material.classesDexSha256.toString('base64')   : null,
+    apkSize:              material.apkSize             != null ? material.apkSize                        : null,
+    apkSha256Full:        material.apkSha256Full       ? material.apkSha256Full.toString('base64')       : null,
+    apkSha256First10M:    material.apkSha256First10M   ? material.apkSha256First10M.toString('base64')   : null,
+    gpHash:               material.gpHash || null,
+    certificates:         material.certificates.map(c => c.toString('base64')),
+    apkVersion:           material.apkVersion || null,
+    apkVersionCode:       material.apkVersionCode || null
   };
 }
 
@@ -431,12 +471,17 @@ function materialFromJson(json) {
     throw new Error('android APK material file is incomplete');
   }
   return {
-    packageName:    json.packageName || PERSONAL_PACKAGE,
-    secretKey:      Buffer.from(json.secretKey, 'base64'),
-    classesDexMd5:  Buffer.from(json.classesDexMd5, 'base64'),
-    certificates:   json.certificates.map(c => Buffer.from(c, 'base64')),
-    apkVersion:     json.apkVersion || null,
-    apkVersionCode: json.apkVersionCode || null
+    packageName:          json.packageName || PERSONAL_PACKAGE,
+    secretKey:            Buffer.from(json.secretKey, 'base64'),
+    classesDexMd5:        Buffer.from(json.classesDexMd5, 'base64'),
+    classesDexSha256:     json.classesDexSha256   ? Buffer.from(json.classesDexSha256, 'base64')   : null,
+    apkSize:              json.apkSize             != null ? json.apkSize                            : null,
+    apkSha256Full:        json.apkSha256Full       ? Buffer.from(json.apkSha256Full, 'base64')       : null,
+    apkSha256First10M:    json.apkSha256First10M   ? Buffer.from(json.apkSha256First10M, 'base64')   : null,
+    gpHash:               json.gpHash || null,
+    certificates:         json.certificates.map(c => Buffer.from(c, 'base64')),
+    apkVersion:           json.apkVersion || null,
+    apkVersionCode:       json.apkVersionCode || null
   };
 }
 
@@ -446,6 +491,7 @@ module.exports = {
   describeCertificate,
   looksLikeWhatsAppCertificate,
   deriveSecretKey,
+  permissionsHash,
   computeToken,
   materialToJson,
   materialFromJson,

package/lib/Attestation.js

@@ -1,5 +1,5 @@
 'use strict';
-
+//
 // ─── Device attestation client ────────────────────────────────────────────────
 //
 // Talks to the on-device Frida attestation server shipped in ./frida (Android
@@ -64,15 +64,29 @@ function generateGeToken() {
 }
 
 // ─── _ga: app analytics envelope ─────────────────────────────────────────────
-// bi = SHA-512 of the session nonce (deterministic per session, unique per
-// device); ap/ai/ae are numeric constants observed across Android builds;
-// mp/mu are multi-profile/multi-user booleans (false on a single-user install).
-function generateGaToken(nonceB64) {
-  const nonceBuf = Buffer.from(
-    (nonceB64 || '').replace(/-/g, '+').replace(/_/g, '/'), 'base64'
-  );
-  const bi = crypto.createHash('sha512').update(nonceBuf).digest('base64');
-  const json = '{"bi":"' + bi + '","ap":247444,"ai":145847,"mp":false,"ae":128383,"mu":false}';
+// 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
+// ae    age of the oldest file in the external files directory, a little
+//       younger than ai
+// 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) {
+  const aesKey    = sha256(Buffer.from(authKeyRaw.toString('base64'), 'utf8'));
+  const plaintext = Buffer.from(crypto.randomBytes(32).toString('base64'), 'utf8');
+  const iv        = crypto.randomBytes(16);
+  const cipher    = crypto.createCipheriv('aes-256-cbc', aesKey, iv);
+  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
+
+  const json = '{"bi":"' + bi + '","ap":' + ap + ',"ai":' + ai + ',"mp":false,"ae":' + ae + ',"mu":false}';
   return encodeURIComponent(json);
 }
 
@@ -120,6 +134,92 @@ function generateGsToken() {
   return encodeURIComponent('{"em":"' + em + '"}');
 }
 
+// ─── Integrity envelope shared by _gg and _gi ────────────────────────────────
+// AES-256-CBC, key = SHA256(standard base64 of the 32-byte auth key), a random
+// 16-byte IV prepended to the ciphertext, then standard base64.
+function integrityEnvelope(authKeyRaw, json) {
+  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 encodeURIComponent(Buffer.concat([iv, ct]).toString('base64'));
+}
+
+// ─── _gg: Play Integrity status ──────────────────────────────────────────────
+// {"_ic": N, "_it": "<token>"}
+//   _ic — 0 on success, 1003 when the provider is not prepared (no GMS)
+//   _it — the Play Integrity token, or the literal "undefined" on error
+function generateGgToken(authKeyRaw, icCode, itToken) {
+  const json = '{"_ic":' + icCode + ',"_it":"' + String(itToken).replace(/\//g, '\\/') + '"}';
+  return integrityEnvelope(authKeyRaw, json);
+}
+
+// ─── _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=';
+
+function generateGpToken(material) {
+  const hash = (material && material.gpHash) || GP_ANDROID12;
+  return encodeURIComponent(hash);
+}
+
+// ─── _gi: installation integrity ─────────────────────────────────────────────
+// Ten keys, in this order:
+//   _dh  SHA256(classes.dex of base.apk)
+//   _iln SHA256 of the sorted .so names the app unpacks under its data
+//        directory (files/decompressed/libs.spo); fixed per package, below
+//   _isb size of base.apk in bytes, as a string
+//   _ip  package name
+//   did  Build.ID + "." + Build.VERSION.INCREMENTAL
+//   _p   ApplicationInfo.sourceDir, the installed base.apk path
+//   _ln  SHA256 of the names in nativeLibraryDir; that directory is empty on
+//        current builds, so the app hashes its fallback string "signal_error"
+//   _ist SHA256(first 10 MiB of base.apk)
+//   _icr SHA1(DER signing certificate)
+//   _is  SHA256(base.apk)
+// Values are standard base64 with '/' written as '\/'. Returns null when the
+// material predates these hashes, so the field is omitted instead of faked.
+const GI_ILN = {
+  'com.whatsapp':     'i7ls4vAnG2Bvmsp8NDKh7uREGcY4q8Hi4JtdCLix+Cc=',
+  'com.whatsapp.w4b': 'Mw3rbAdtB9wUHE6w9vpff27e6I9/ruCa555vkJXh+N4='
+};
+const GI_LN = crypto.createHash('sha256').update('signal_error').digest('base64');
+
+// install: { did, sourceDir } — the firmware string and the base.apk path of
+// the install this session claims to be.
+function generateGiToken(authKeyRaw, material, install) {
+  if (!material || !material.classesDexSha256 || material.apkSize == null ||
+      !material.apkSha256Full || !material.apkSha256First10M ||
+      !material.certificates || !material.certificates.length ||
+      !install || !install.did || !install.sourceDir) {
+    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 = '{' +
+    '"_dh":"'  + b64(material.classesDexSha256)  + '",' +
+    '"_iln":"' + esc(iln)                        + '",' +
+    '"_isb":"' + String(material.apkSize)        + '",' +
+    '"_ip":"'  + esc(pkg)                        + '",' +
+    '"did":"'  + esc(install.did)                + '",' +
+    '"_p":"'   + esc(install.sourceDir)          + '",' +
+    '"_ln":"'  + esc(GI_LN)                      + '",' +
+    '"_ist":"' + b64(material.apkSha256First10M) + '",' +
+    '"_icr":"' + b64(crypto.createHash('sha1').update(material.certificates[0]).digest()) + '",' +
+    '"_is":"'  + b64(material.apkSha256Full)     + '"' +
+  '}';
+  return integrityEnvelope(authKeyRaw, json);
+}
+
 // ─── Empty (NONE) fallbacks ───────────────────────────────────────────────────
 
 const EMPTY_ANDROID = { gpia: '', gg: '', gi: '', gp: '', ge: '', ga: '' };
@@ -268,13 +368,23 @@ async function attestationFields(device, nonceB64, opts) {
     const a  = await androidIntegrity(nonceB64 || '', device);
     const gs = generateGsToken();
     const ge = generateGeToken();
-    const ga = generateGaToken(nonceB64 || '');
+    // The envelope key comes from the Noise static public key; a random one
+    // still yields a well-formed field when the caller has no key to give.
+    const authKeyRaw = (Buffer.isBuffer(opts.authKeyRaw) && opts.authKeyRaw.length === 32)
+      ? opts.authKeyRaw
+      : crypto.randomBytes(32);
+    const ga = opts.ga || generateGaToken(authKeyRaw);
+    const gg = a.gpia
+      ? generateGgToken(authKeyRaw, 0, a.gpia)
+      : generateGgToken(authKeyRaw, 1003, 'undefined');
+    const gp = generateGpToken(opts.apkMaterial || null);
+    const gi = generateGiToken(authKeyRaw, opts.apkMaterial || null, opts.install || null);
     _ok('_gs field generated (WASafe envelope, ' + gs.length + ' encoded chars)');
     return [
       'gpia',       orNull(a.gpia),
-      '_gg',        orNull(a.gg),
-      '_gi',        orNull(a.gi),
-      '_gp',        orNull(a.gp),
+      '_gg',        gg,
+      '_gi',        gi,
+      '_gp',        gp,
       '_ge',        ge,
       '_ga',        ga,
       '_gs',        gs,
@@ -311,6 +421,7 @@ module.exports = {
   attestationFields,
   attestBody,
   androidInfo,
+  generateGaToken,
   toHex,
   toBase64Url,
   EMPTY_ANDROID,

package/lib/Registration.js

@@ -1,8 +1,9 @@
 'use strict';
-//registration tool
+//registration tool//
 const crypto = require('crypto');
 const https  = require('https');
 const tls    = require('tls');
+const zlib   = require('zlib');
 const fs     = require('fs');
 const os     = require('os');
 const path   = require('path');
@@ -40,13 +41,18 @@ function _uaPlatformName(device) {
 
 function registrationHeaders(device, waVersion) {
   if (device.os === 'android') {
+    // Header set and order mirror the native client's registration POST: no
+    // Accept, Connection kept alive, gzip advertised (the response is gunzipped
+    // on both the direct and SOCKS paths). request_token is an UPPERCASE UUID —
+    // the native client never mints a lowercase one.
     return {
-      'User-Agent':     `WhatsApp/${waVersion} ${_uaPlatformName(device)}/${device.osVersion} Device/${device.manufacturer}-${device.modelId}`,
-      'Content-Type':   'application/x-www-form-urlencoded',
-      'Accept':         'text/json',
-      'WaMsysRequest':  '1',
+      'User-Agent':      `WhatsApp/${waVersion} ${_uaPlatformName(device)}/${device.osVersion} Device/${device.manufacturer}-${device.modelId}`,
+      'WaMsysRequest':   '1',
       // A fresh one per request, the way the native client mints it.
-      'request_token':  uuidv4()
+      'request_token':   uuidv4().toUpperCase(),
+      'Content-Type':    'application/x-www-form-urlencoded',
+      'Connection':      'Keep-Alive',
+      'Accept-Encoding': 'gzip'
     };
   }
   return {
@@ -66,7 +72,7 @@ const {
   parseSocksProxy, socksProxyUrl, socksConnect, proxyAgent
 } = require('./socks');
 
-async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, device) {
+async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, device, query) {
   const dHost = 'v.whatsapp.net';
   const dPort = 443;
 
@@ -88,23 +94,27 @@ async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, dev
   });
 
   const headers  = registrationHeaders(device || getDeviceConfig(), waVersion);
+  // The native client submits the parameters twice: once in the clear as the
+  // URL query, once encrypted inside ENC. The query string here is the exact
+  // plaintext that was encrypted, byte for byte.
+  const target   = query ? `/v2${path}?${query}` : `/v2${path}`;
   const reqLines = [
-    `POST /v2${path} HTTP/1.1`,
+    `POST ${target} HTTP/1.1`,
     `Host: ${dHost}`,
     ...Object.keys(headers).map(k => `${k}: ${headers[k]}`),
     `Content-Length: ${Buffer.byteLength(body)}`
   ];
   if (authHeader) reqLines.push(`Authorization: ${authHeader}`);
-  // 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);
+  // Connection: Keep-Alive rides in from registrationHeaders, matching the
+  // native client; the response is still delimited by its own length and the
+  // socket is destroyed once it is read.
+  reqLines.push('', body);
   const req = reqLines.join('\r\n');
 
   tlsSocket.write(req);
 
-  const { status, body: bodyBuf } = await readHttpResponse(tlsSocket, path);
-  const bodyStr = bodyBuf.toString('utf8');
+  const { status, headers: resHeaders, body: bodyBuf } = await readHttpResponse(tlsSocket, path);
+  const bodyStr = decodeBody(bodyBuf, resHeaders).toString('utf8');
 
   if (status !== 200) throw new Error(`HTTP ${status} ${path}: ${bodyStr}`);
   try { return JSON.parse(bodyStr); } catch (_) { return { raw: bodyStr }; }
@@ -172,6 +182,17 @@ function readHttpResponse(socket, label, timeoutMs) {
   });
 }
 
+// The registration POST advertises `Accept-Encoding: gzip`, so the server may
+// answer gzip-compressed. Decode by the response's own content-encoding; fall
+// back to the raw bytes if the header lies or the stream will not inflate, so a
+// plain reply still parses. `headers` is the raw header block (any case).
+function decodeBody(bodyBuf, headers) {
+  if (/^content-encoding:[ \t]*gzip/im.test(headers || '')) {
+    try { return zlib.gunzipSync(bodyBuf); } catch (_) { /* fall through */ }
+  }
+  return bodyBuf;
+}
+
 /**
  * Parse what has arrived so far.
  *
@@ -1221,6 +1242,61 @@ function toUrlHex(buf) {
 // IMPORTANT: do NOT use URLSearchParams here — it would double-encode the
 //            percent-hex sequences in the 'id' field (%AA → %25AA).
 
+// 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
+// for /v2/code, 49 for /v2/register. gpia/token/vname that this build omits
+// simply drop out — their slots collapse.
+const CODE_PARAM_ORDER = [
+  'method', 'backup_token', '_gs', 'sim_mnc', 'id', 'mnc', '_gg',
+  'network_radio_type', 'lg', 'rc', 'pid', '_ge', 'cellular_strength', 'gpia',
+  'hasinrc', 'aid', 'mcc', '_gp', 'hasav', 'device_ram', 'db', 'sim_type',
+  'prefer_sms_over_flash', 'access_session_id', 'sim_mcc', 'roaming_type',
+  'mistyped', 'airplane_mode_type', 'e_ident', 'e_skey_sig', 'entrypoint',
+  'token', 'in', 'expid', 'simnum', 'cc', 'education_screen_displayed',
+  'e_skey_val', 'authkey', 'e_keytype', 'e_regid', 'client_metrics', '_gi',
+  'e_skey_id', 'feo2_query_status', 'reason', 'fdid', 'recaptcha', '_ga', 'lc'
+];
+
+const REGISTER_PARAM_ORDER = [
+  'code', 'backup_token', 'sim_mnc', '_gs', 'id', 'device_ram', 'db', '_gg',
+  'sim_operator_name', 'passkey_login_status', 'lg', 'rc', 'network_radio_type',
+  'pid', '_ge', 'cellular_strength', 'gpia', 'hasinrc', 'aid',
+  'network_operator_name', 'mcc', '_gp', 'mnc', 'entered', 'access_session_id',
+  'sim_mcc', 'roaming_type', 'mistyped', 'airplane_mode_type', 'has_play_store',
+  'sim_type', 'e_ident', 'e_skey_sig', 'entrypoint', 'in', 'expid', 'simnum',
+  'cc', 'e_skey_val', 'authkey', 'e_keytype', 'e_regid', '_gi', 'client_metrics',
+  'e_skey_id', 'fdid', 'recaptcha', '_ga', 'lc'
+];
+
+// Reorder a flat [k, v, k, v, …] list to the native insertion order for the
+// endpoint. Keys outside the reference order (push_token and any build-specific
+// extras) keep their relative order and trail the known fields, so nothing is
+// dropped. Only /v2/code and /v2/register have a reference order; every other
+// endpoint (client_log, exist, …) and every non-Android device passes through
+// untouched.
+function reorderRegistrationPairs(pairs, path, device) {
+  const order = path === '/code' ? CODE_PARAM_ORDER
+              : path === '/register' ? REGISTER_PARAM_ORDER
+              : null;
+  if (!order || !device || device.os !== 'android') return pairs;
+
+  const orderSet = new Set(order);
+  const seen     = new Map();
+  const extras   = [];
+  for (let i = 0; i < pairs.length; i += 2) {
+    const k = pairs[i];
+    if (seen.has(k)) continue;
+    seen.set(k, pairs[i + 1]);
+    if (!orderSet.has(k)) extras.push(k);
+  }
+
+  const out = [];
+  for (const k of order)  if (seen.has(k)) out.push(k, seen.get(k));
+  for (const k of extras) out.push(k, seen.get(k));
+  return out;
+}
+
 function buildForm(pairs, extraPairs) {
   const parts = [];
   for (let i = 0; i < pairs.length; i += 2) {
@@ -1339,15 +1415,59 @@ function getAppPid(store) {
   return store._appPid;
 }
 
-// is_sim_absent used to be the constant false while the same request could send
-// sim_mcc/sim_mnc as 000/000 — which is precisely what a handset reports when
-// there is no SIM in it. One request then said both "a SIM is present" and "no
-// operator", which no real handset ever says. Reading it off the operator the
-// request actually declares keeps the two halves telling one story.
-function buildClientMetrics(attempt, meta) {
+// ---------- the install _gi describes ----------
+//
+// sourceDir is where Android put base.apk: two random 16-byte tags, each
+// URL-safe base64 with padding, as PackageManager names them. did is the
+// firmware: Build.ID, a dot, Build.VERSION.INCREMENTAL. Samsung's incremental
+// is the model without "SM-", region XX, update type U, bootloader revision,
+// major release, year (X = 2024) and month letters and a build digit; other
+// vendors are given a numeric one. Both belong to one install, so they come
+// from the session identity like pid and stay put across /code and /register.
+function getInstallIdentity(store, device, packageName) {
+  const seed = (store.identityId && Buffer.isBuffer(store.identityId))
+    ? store.identityId
+    : Buffer.from(String(store.phoneNumber || ''), 'utf8');
+  const h = (label) => crypto.createHash('sha256').update(seed).update(label).digest();
+  const tag = (label) => h(label).subarray(0, 16).toString('base64')
+    .replace(/\+/g, '-').replace(/\//g, '_');
+
+  const sourceDir = '/data/app/~~' + tag('apkdir') + '/' +
+    packageName + '-' + tag('pkgdir') + '/base.apk';
+
+  let incremental = device && device.osBuildIncremental;
+  if (!incremental) {
+    const f = h('firmware');
+    const model = String((device && device.modelId) || '');
+    if (/^SM-/i.test(model)) {
+      incremental = model.replace(/^SM-/i, '').toUpperCase() + 'XXU' +
+        String(1 + f[0] % 3) +
+        'ABC'[f[1] % 3] +
+        'X' +
+        'ABCDEFGHIJKL'[f[2] % 12] +
+        String(1 + f[3] % 9);
+    } else {
+      incremental = String(10000000 + f.readUInt32BE(4) % 90000000);
+    }
+  }
+  const buildId = (device && device.osBuildNumber) || 'UP1A.231005.007';
+
+  return { did: buildId + '.' + incremental, sourceDir };
+}
+
+// Whether the request describes a phone with no SIM in it. The operator code
+// is the tell: a real mcc means a card is present, a missing or all-zero mcc
+// means none. Every SIM-shaped field (is_sim_absent here, sim_type/simnum and
+// the operator fields in getRequestVerificationCodeParameters) reads it off
+// this one test, so a request never says a SIM is both present and absent.
+function _simAbsent(meta) {
   const mcc = meta && meta.mcc != null ? String(meta.mcc).trim() : '';
-  const simAbsent = !/^\d+$/.test(mcc) || /^0+$/.test(mcc);
-  const json = '{"attempts":' + (attempt || 1)
+  return !/^\d+$/.test(mcc) || /^0+$/.test(mcc);
+}
+
+function buildClientMetrics(attempt, meta) {
+  const simAbsent = _simAbsent(meta);
+  const json = '{"attempts":' + (attempt == null ? 1 : attempt)
     + ',"app_campaign_download_source":"google-play|unknown"'
     + ',"is_sim_absent":' + (simAbsent ? 'true' : 'false') + '}';
   return encodeURIComponent(json);
@@ -1382,20 +1502,30 @@ function getRequestVerificationCodeParameters(store, method, meta, device, attem
     // otherwise gets the request answered with an SMS — or with no route at
     // all. They stay at their headless-safe values for every other method.
     const wantsFlash = method === 'flash';
+    // One SIM story across every field. The operator codes decide it: a real
+    // mcc means a SIM is in the phone, so sim_type and simnum say "present" and
+    // the four operator fields carry the home network. A missing or all-zero
+    // mcc is a phone with no SIM, which reports "000" in all four and both SIM
+    // flags at 0 — the shape a device on Wi-Fi without a card actually sends.
+    // buildClientMetrics reads is_sim_absent off the same test, so the request
+    // never says a SIM is both there and not.
+    const simAbsent = _simAbsent(meta);
+    const simMcc    = simAbsent ? '000' : meta.mcc;
+    const simMnc    = simAbsent ? '000' : meta.mnc;
     return [
       'method',                     method,
-      'sim_mcc',                    meta.mcc,
-      'sim_mnc',                    meta.mnc,
+      'sim_mcc',                    simMcc,
+      'sim_mnc',                    simMnc,
       'reason',                     '',
-      'mcc',                        meta.mcc,
-      'mnc',                        meta.mnc,
+      'mcc',                        simMcc,
+      'mnc',                        simMnc,
       'feo2_query_status',          'success_get_client_capabilities',
       'db',                         '1',
-      'sim_type',                   '1',
+      'sim_type',                   simAbsent ? '0' : '1',
       'recaptcha',                  '%7B%22stage%22%3A%22ABPROP_DISABLED%22%7D',
       'network_radio_type',         '1',
       'prefer_sms_over_flash',      wantsFlash ? 'true' : 'false',
-      'simnum',                     '0',
+      'simnum',                     simAbsent ? '0' : '1',
       'airplane_mode_type',         '0',
       'client_metrics',             buildClientMetrics(attempt, meta),
       'mistyped',                   '7',
@@ -1431,6 +1561,31 @@ function getRequestVerificationCodeParameters(store, method, meta, device, attem
   ];
 }
 
+// ---------- /register device parameters (Android) ----------
+//
+// The Android app sends its device description again on /register, with the
+// values it sent on /code, so they are taken from the /code list rather than
+// restated. client_metrics is rebuilt: its attempt counter restarts at 0 on
+// this screen.
+const REGISTER_DEVICE_FIELDS = new Set([
+  'backup_token', 'sim_mnc', 'device_ram', 'db', 'network_radio_type', 'pid',
+  'cellular_strength', 'hasinrc', 'aid', 'mcc', 'mnc', 'sim_mcc',
+  'roaming_type', 'mistyped', 'airplane_mode_type', 'sim_type', 'simnum',
+  'recaptcha'
+]);
+
+function getRegisterDeviceParameters(store, meta, device) {
+  if (!device || device.os !== 'android') return [];
+  const code = getRequestVerificationCodeParameters(
+    store, store.codeMethod || 'sms', meta, device, 0);
+  const out = [];
+  for (let i = 0; i < code.length; i += 2) {
+    if (REGISTER_DEVICE_FIELDS.has(code[i])) out.push(code[i], code[i + 1]);
+  }
+  out.push('client_metrics', buildClientMetrics(0, meta));
+  return out;
+}
+
 // ---------- Payload ----------
 
 // base64url WITH padding — matches Java's Base64.getUrlEncoder().encodeToString()
@@ -1506,7 +1661,7 @@ function buildVerifiedNameCertificate(store, device) {
   ]));
 }
 
-async function buildPayload(store, waVersion, useToken, extraPairs) {
+async function buildPayload(store, waVersion, useToken, extraPairs, path) {
   const { cc, national } = parsePhone(store.phoneNumber);
   const meta   = getCountryMeta(cc, store);
   const device = store.device || getDeviceConfig();
@@ -1537,9 +1692,21 @@ async function buildPayload(store, waVersion, useToken, extraPairs) {
   // were wired up.
   const pushToken = await pushClientFor(device).getPushToken(store, device);
 
-  const attestFields = await attestation.attestationFields(device, nonceB64, { pushToken });
+  const authKeyRaw  = stripKeyPrefix(store.noiseKeyPair.public);
+  const apkMaterial = device.os === 'android' ? tryLoadAndroidMaterial(device) : null;
+  // One _ga per session: the app sends the same one on /code and /register.
+  if (device.os === 'android' && !store._gaToken) {
+    store._gaToken = attestation.generateGaToken(authKeyRaw);
+  }
+  const attestFields = await attestation.attestationFields(device, nonceB64, {
+    pushToken,
+    authKeyRaw,
+    apkMaterial,
+    install: apkMaterial ? getInstallIdentity(store, device, apkMaterial.packageName) : null,
+    ga: store._gaToken
+  });
 
-  return buildForm([
+  const basePairs = [
     'cc',                cc,
     'in',                national,
     'rc',                String(RELEASE_CHANNEL),
@@ -1561,7 +1728,12 @@ async function buildPayload(store, waVersion, useToken, extraPairs) {
     'access_session_id', getAccessSessionId(store),
     'token',             token,
     ...attestFields
-  ], extraPairs);
+  ];
+  const allPairs = extraPairs ? basePairs.concat(extraPairs) : basePairs;
+  // Emit the fields in the native client's fixed insertion order for /code and
+  // /register. The order is part of the wire fingerprint and, with the query
+  // now mirrored into the URL, is visible to the server in the clear.
+  return buildForm(reorderRegistrationPairs(allPairs, path, device));
 }
 
 // ---------- Encryption (AES-256-GCM, ephemeral X25519) ----------
@@ -1581,9 +1753,9 @@ function encryptPayload(plaintext) {
 
 // ---------- HTTP ----------
 
-function httpPost(path, body, waVersion, authHeader, device) {
+function httpPost(path, body, waVersion, authHeader, device, query) {
   const proxy = socksProxyUrl();
-  if (proxy) return httpPostViaSocks(path, body, waVersion, proxy, authHeader, device);
+  if (proxy) return httpPostViaSocks(path, body, waVersion, proxy, authHeader, device, query);
 
   return new Promise((resolve, reject) => {
     const bodyBuf = Buffer.from(body, 'utf8');
@@ -1594,10 +1766,13 @@ function httpPost(path, body, waVersion, authHeader, device) {
     // Attestation cert-chain / App Attest header (Android cert chain, iOS
     // <attestation>|<keyId>). Only present when body attestation is available.
     if (authHeader) headers['Authorization'] = authHeader;
+    // The native client submits the parameters twice: once in the clear as the
+    // URL query, once encrypted inside ENC. The query is the exact ENC
+    // plaintext, byte for byte.
     const opts = {
       hostname: 'v.whatsapp.net',
       port: 443,
-      path: '/v2' + path,
+      path: query ? '/v2' + path + '?' + query : '/v2' + path,
       method: 'POST',
       timeout: 20000,
       headers
@@ -1606,7 +1781,12 @@ function httpPost(path, body, waVersion, authHeader, device) {
       const chunks = [];
       res.on('data', d => chunks.push(d));
       res.on('end', () => {
-        const text = Buffer.concat(chunks).toString('utf8');
+        const encoding = String(res.headers['content-encoding'] || '');
+        let buf = Buffer.concat(chunks);
+        if (/gzip/i.test(encoding)) {
+          try { buf = zlib.gunzipSync(buf); } catch (_) { /* keep raw */ }
+        }
+        const text = buf.toString('utf8');
         if (res.statusCode !== 200) {
           return reject(new Error(`HTTP ${res.statusCode} ${path}: ${text}`));
         }
@@ -1622,7 +1802,7 @@ function httpPost(path, body, waVersion, authHeader, device) {
 }
 
 async function sendRequest(path, store, waVersion, useToken, extraPairs) {
-  const plaintext = await buildPayload(store, waVersion, useToken, extraPairs);
+  const plaintext = await buildPayload(store, waVersion, useToken, extraPairs, path);
   return sendEncrypted(path, plaintext, store, waVersion);
 }
 
@@ -1650,7 +1830,14 @@ async function sendEncrypted(path, plaintext, store, waVersion) {
 
   _whaDbg('[DBG] REG → ' + path + ' (' + body.length + ' bytes' +
     (bodyAtt.bodyAttestation ? ', attested' : '') + ')');
-  const result = await httpPost(path, body, waVersion, bodyAtt.authorizationHeader, device);
+  // The ENC plaintext is also the URL query: the native client submits every
+  // parameter twice, in the clear and encrypted, byte for byte identical. This
+  // is documented and verified only for the Android /code and /register
+  // requests, so the mirror is scoped to them; iOS and the funnel endpoints
+  // keep posting to a bare path, exactly as before.
+  const mirrorQuery = device.os === 'android' && (path === '/code' || path === '/register');
+  const result = await httpPost(path, body, waVersion, bodyAtt.authorizationHeader, device,
+    mirrorQuery ? plaintext : undefined);
   _whaDbg('[DBG] REG ← ' + path + ' ' +
     (result && result.status ? result.status : JSON.stringify(result).slice(0, 120)) +
     (result && result.reason ? ' reason=' + result.reason : ''));
@@ -2403,14 +2590,17 @@ async function verifyCode(store, code, opts) {
   const screen = currentVerifyScreen(store);
   await sendFunnelLog(store, waVersion, screen, 'submit_code', 'submit_code_attempt');
 
-  const result = await sendRequest('/register', store, waVersion, true, [
+  // The Android app sends the setup token on /code only; iOS keeps it here.
+  const registerMeta = getCountryMeta(parsePhone(store.phoneNumber).cc, store);
+  const result = await sendRequest('/register', store, waVersion, _device.os !== 'android', [
     'code',                   normalized,
     'sim_operator_name',      '',
     'passkey_login_status',   'not_attempted',
     'network_operator_name',  '',
     'entered',                '1',
     'has_play_store',         'true',
-    'entrypoint',             'suma'
+    'entrypoint',             'suma',
+    ...getRegisterDeviceParameters(store, registerMeta, _device)
   ]);
 
   const status = result.status;
@@ -2494,7 +2684,7 @@ async function verifyCode(store, code, opts) {
 module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchPlayVersion, fetchAndroidVersionLive, fetchWaVersion, currentVersionFor, refreshSessionVersion, clearVersionCache, tryLoadAndroidMaterial, compareVersions, parsePhone, getCountryMeta, assertRegistrationKeys, parseSocksProxy, socksProxyUrl };
 
 // The HTTP reader, exposed for tests. Not part of the public API.
-module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody };
+module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody, decodeBody, reorderRegistrationPairs };
 
 // Token computation, exposed for tests. Not part of the public API.
 module.exports._token = { computeToken, androidMaterialPath, registrationHeaders, ensureAndroidMaterial, deviceForRegistration, buildVerifiedNameCertificate, buildPayload };
@@ -2504,7 +2694,7 @@ module.exports._verify = {
   hasChallenge, is2FARequired, decodeOrNull, isSuccessful,
   normalizeCodeResult, currentVerifyScreen, adoptCanonicalNumber, funnelEnabled, waitHint,
   flashCodeFromCallerId, flashCodeLength, applyFlashFilter, codeForSubmission,
-  getRequestVerificationCodeParameters
+  getRequestVerificationCodeParameters, getRegisterDeviceParameters, getInstallIdentity
 };
 
 // Pacing internals, exposed for tests. Not part of the public API.

package/lib/Store.js

@@ -209,6 +209,11 @@ function storeToJson(store) {
     // call it has to know, since that code is read off the caller ID rather
     // than out of a message.
     codeMethod:     store.codeMethod || null,
+    // /code and /register come from one running app, which sends the same
+    // access_session_id and the same _ga in both; the steps are usually
+    // separate commands, so both are written down rather than drawn again.
+    accessSessionId: store._accessSessionId || null,
+    gaToken:         store._gaToken || null,
     // 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.
@@ -266,6 +271,8 @@ function storeFromJson(obj) {
     simMnc:         obj.simMnc || null,
     codePending:    obj.codePending || false,
     codeMethod:     obj.codeMethod || null,
+    _accessSessionId: obj.accessSessionId || undefined,
+    _gaToken:         obj.gaToken || undefined,
     // Absent on stores written before push tokens existed; null simply means
     // the first registration step will fetch one.
     fcm:            obj.fcm || null,

package/package.json

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