whalibmob 5.33.22 → 5.33.26

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,5 +1,5 @@
 'use strict';
-//registration tool
+//registration tool//
 const crypto = require('crypto');
 const https  = require('https');
 const tls    = require('tls');
@@ -1339,15 +1339,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 +1426,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 +1485,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()
@@ -1537,7 +1616,19 @@ 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([
     'cc',                cc,
@@ -2403,14 +2494,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;
@@ -2504,7 +2598,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.22",
+  "version": "5.33.26",
   "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",