whalibmob 5.12.10 → 5.12.11

package/.env.example

@@ -53,13 +53,28 @@
 # ─── WhatsApp version ────────────────────────────────────────────────────────
 # Pin the WhatsApp client version. When set, the live version lookup is skipped
 # entirely. Leave unset to fetch the current version automatically (recommended).
+#
+# On Android this is normally not needed either way: the version is taken from
+# the APK the token material came from, since the token is signed over that
+# build. Setting this still overrides it.
 # WA_VERSION=2.24.10.75
 
-# Override the static registration token. Leave unset to use the built-in token
-# for the selected platform — only change this if you know what you are doing.
+# Override the static registration token. iOS only — Android has no static token
+# and signs its own out of the APK (see below). Leave unset to use the built-in
+# one; only change this if you know what you are doing.
 # WA_STATIC_TOKEN=
 
 
+# ─── Android registration token material ─────────────────────────────────────
+# Registering with WA_OS=android needs material read out of a WhatsApp APK once:
+#
+#     wa apk-material base.apk [split_config.xxhdpi.apk ...]
+#
+# It is written to <session dir>/android-apk-material.json by default. Set this
+# to keep it somewhere else. Registering as iOS needs none of it.
+# WA_ANDROID_APK_MATERIAL=/path/to/android-apk-material.json
+
+
 # ─── Proxy ───────────────────────────────────────────────────────────────────
 # Route registration traffic through a SOCKS proxy. Requires the `socks`
 # package: npm install socks

package/README.md

@@ -120,6 +120,7 @@ npm install -g whalibmob
 - [Library API](#library-api)
   - [Connecting Account](#connecting-account)
     - [Register a New Number](#register-a-new-number)
+    - [Registering as Android](#registering-as-android)
     - [Device Attestation with Frida (optional)](#device-attestation-with-frida-optional)
     - [Connect](#connect)
   - [Linking to an Existing Account (Pairing Code)](#linking-to-an-existing-account-pairing-code)
@@ -273,6 +274,10 @@ wa version
 
 Registration is a one-time process. You need a phone number that can receive an SMS or voice call. **Use a dedicated number** — do not use a number already active on a real WhatsApp device.
 
+> [!IMPORTANT]
+> Registering as **Android** (`WA_OS=android`) needs one extra step first — see
+> [Registering as Android](#registering-as-android). Registering as iOS, the default, does not.
+
 **Step 1 — request a verification code**
 
 ```sh
@@ -1544,6 +1549,80 @@ Both are optional and both keep working when omitted — you get an error naming
 > [!NOTE]
 > Registration reports the screens it passes through to WhatsApp's `/client_log`, the way the phone clients do — a client that registers in total silence does something no real installation does. It is fire-and-forget and every failure is swallowed, so it can never take a registration down. Set `WA_FUNNEL_LOG=0` to send none of it.
 
+### Registering as Android
+
+The registration token is computed differently on each platform, and only iOS
+derives it from a constant. The Android client signs it with material out of its
+own APK:
+
+```
+key   = PBKDF2-HMAC-SHA1(password = "com.whatsapp" + about_logo.png,
+                         salt = fixed, iterations = 128, length = 64)
+token = urlencode(base64(HMAC-SHA1(key, signing certificates
+                                      + MD5(classes.dex)
+                                      + national number)))
+```
+
+None of that can be derived, so it has to be read out of a real APK once. Sending
+the iOS-shaped token as Android is answered with `{"reason":"bad_token"}`, and no
+value in `WA_STATIC_TOKEN` changes that — the constant is not what is wrong, the
+formula is. `WA_STATIC_TOKEN` applies to iOS only.
+
+**Get an APK.** Pull it off any phone or emulator that has WhatsApp installed:
+
+```sh
+adb shell pm path com.whatsapp
+# package:/data/app/~~xyz==/com.whatsapp-abc==/base.apk
+# package:/data/app/~~xyz==/com.whatsapp-abc==/split_config.xxhdpi.apk
+adb pull /data/app/~~xyz==/com.whatsapp-abc==/base.apk
+adb pull /data/app/~~xyz==/com.whatsapp-abc==/split_config.xxhdpi.apk
+```
+
+Recent releases ship as an App Bundle, so `about_logo.png` often lives in a
+density split rather than in `base.apk`. Pull the `split_config.*dpi.apk` files
+too and pass them along — only splits whose name ends in `dpi` are searched.
+
+**Read the material out of it:**
+
+```sh
+wa apk-material base.apk split_config.xxhdpi.apk
+```
+
+```
+reading base.apk...
+  package               com.whatsapp
+  version               2.26.25.80  (code 260908001)
+  certificates          1
+  classes.dex md5       5c71f02aaad331e16e436bfa83ea3c5b
+  written to            /home/you/.waSession/android-apk-material.json
+```
+
+Only the derived pieces are kept — the APK is never needed again. Registration
+picks the file up on its own from then on. `--out <file>` writes it elsewhere,
+and `WA_ANDROID_APK_MATERIAL` points at it if you keep it somewhere else.
+
+**The version comes from the APK too.** It is read out of the binary
+`AndroidManifest.xml` and announced from then on, instead of the version the Play
+Store currently lists. The token is signed over *this* build's `classes.dex`, so
+announcing any other version describes a build the token does not belong to.
+`WA_VERSION` still overrides everything if you need it to; on a manifest with no
+`versionName`, pass `--version <x.y.z.w>`.
+
+**Re-run it when you update the APK.** `classes.dex` changes with every WhatsApp
+release, and its MD5 is signed into the token.
+
+Programmatically:
+
+```js
+const { extractMaterial, computeToken, materialToJson } = require('whalibmob/lib/AndroidApk')
+
+const material = extractMaterial(
+  fs.readFileSync('base.apk'),
+  [{ name: 'split_config.xxhdpi.apk', data: fs.readFileSync('split_config.xxhdpi.apk') }]
+)
+fs.writeFileSync('android-apk-material.json', JSON.stringify(materialToJson(material)))
+```
+
 ### Device Attestation with Frida (optional)
 
 WhatsApp's registration servers score every `/code` and `/register` request on how

package/cli.js

@@ -2328,10 +2328,12 @@ usage:
   wa registration --request-code <phone>    request SMS code
   wa registration --register <phone> --code <code>
   wa registration --check <phone>
+  wa apk-material <base.apk> [split.apk ...]  read the Android token material
   wa version
 
 options:
   --session <dir>   session directory  (default: ~/.waSession)
+  --out <file>      where apk-material writes  (default: <session dir>/android-apk-material.json)
   --sms             connect by registering this number over SMS
   --pair            connect by linking to an existing account (8-digit code)
   --method          sms | voice | wa_old | email  (default: sms)
@@ -2434,6 +2436,57 @@ async function main() {
     return;
   }
 
+  // Read the Android registration token material out of a WhatsApp APK.
+  //
+  // Registering as Android signs its token with the APK's own signing
+  // certificates, the MD5 of its classes.dex, and a key derived from
+  // about_logo.png — none of which can be derived, so they are read out of a
+  // real APK once and kept. Registering as iOS needs none of it.
+  if (cmd === 'apk-material') {
+    // parseArgs puts the first non-flag argument in sub, the rest in pos.
+    const apks = [sub, ...pos].filter(Boolean);
+    if (!apks.length) {
+      fail('usage: wa apk-material <base.apk> [split.apk ...]');
+      process.exit(1);
+    }
+    const outFile = flags.out ||
+      process.env.WA_ANDROID_APK_MATERIAL ||
+      path.join(_sessDir, 'android-apk-material.json');
+    try {
+      const AndroidApk = require('./lib/AndroidApk');
+      const [basePath, ...splitPaths] = apks;
+      out('reading ' + basePath + '...');
+      const material = AndroidApk.extractMaterial(
+        fs.readFileSync(basePath),
+        splitPaths.map(p => ({ name: path.basename(p), data: fs.readFileSync(p) }))
+      );
+      if (flags.version) material.apkVersion = String(flags.version);
+      if (!fs.existsSync(_sessDir)) fs.mkdirSync(_sessDir, { recursive: true });
+      fs.writeFileSync(outFile, JSON.stringify(AndroidApk.materialToJson(material), null, 2));
+      kv('package', material.packageName);
+      kv('version', material.apkVersion
+        ? material.apkVersion + (material.apkVersionCode ? '  (code ' + material.apkVersionCode + ')' : '')
+        : '(not in the manifest — pass --version <x.y.z.w>)');
+      kv('certificates', String(material.certificates.length));
+      kv('classes.dex md5', material.classesDexMd5.toString('hex'));
+      kv('written to', outFile);
+      out('');
+      if (material.apkVersion) {
+        out('  Registration will announce ' + material.apkVersion + ' from now on, because the');
+        out('  token is signed over this APK — the live Play Store version would name a');
+        out('  different build. WA_VERSION still overrides it.');
+      } else {
+        out('  The manifest carries no versionName, so the live Play Store version will be');
+        out('  announced. If that does not match this APK, pass --version or set WA_VERSION.');
+      }
+      out('  Re-run this when you update the APK — classes.dex changes every release.');
+    } catch (e) {
+      fail(e.message);
+      process.exit(1);
+    }
+    return;
+  }
+
   if (cmd === 'registration' || cmd === 'reg') {
     const rawPhone =
       flags['request-code'] !== undefined && flags['request-code'] !== true ? String(flags['request-code']) :

package/lib/AndroidApk.js

@@ -0,0 +1,413 @@
+'use strict';
+
+// The Android registration token.
+//
+// iOS derives its token from a static string and the client version, and that
+// is the algorithm this library used for both platforms — with a different
+// constant substituted for Android. There is no such constant: the Android
+// client signs the token with material taken out of its own APK, and no value
+// put in WA_STATIC_TOKEN can stand in for it. Sending the iOS-shaped token as
+// Android is answered with {"reason":"bad_token"}.
+//
+// What the native client actually computes, and what this file reproduces from
+// Cobalt's WhatsAppAndroidClientInfo:
+//
+//   key   = PBKDF2-HMAC-SHA1(password = packageName || about_logo.png,
+//                            salt = ANDROID_SALT, iterations = 128, dkLen = 64)
+//   mac   = HMAC-SHA1(key) over each APK signing certificate in order,
+//           then MD5(classes.dex), then the national number as ASCII
+//   token = urlencode(base64(mac))
+//
+// The three pieces of material live in the APK, so they cannot be derived —
+// they have to be read out of one. extractMaterial does that; the CLI's
+// apk-material command drives it and writes the result where computeToken
+// looks for it.
+
+const crypto = require('crypto');
+const zlib   = require('zlib');
+
+// Reverse engineered from the Android binary and identical for the consumer and
+// business builds. Cobalt notes it has been stable across many releases.
+const ANDROID_SALT = Buffer.from(
+  'PkTwKSZqUfAUyR0rPQ8hYJ0wNsQQ3dW1+3SCnyTXIfEAxxS75FwkDf47wNv/c8pP' +
+  '3p0GXKR6OOQmhyERwx74fw1RYSU10I4r1gyBVDbRJ40pidjM41G1I1oN', 'base64');
+
+// Where about_logo.png has shipped across releases. The base APK is searched in
+// this order first; App Bundle releases moved density-qualified drawables into
+// per-density splits, which is why the splits are searched after it.
+const ABOUT_LOGO_PATHS = [
+  'res/drawable-hdpi/about_logo.png',
+  'res/drawable-hdpi-v4/about_logo.png',
+  'res/drawable-xxhdpi-v4/about_logo.png'
+];
+
+const PERSONAL_PACKAGE = 'com.whatsapp';
+const BUSINESS_PACKAGE = 'com.whatsapp.w4b';
+
+const PBKDF2_ITERATIONS = 128;
+const PBKDF2_KEY_SIZE   = 64;
+
+// ─── ZIP ──────────────────────────────────────────────────────────────────────
+//
+// An APK is a ZIP. Only two things are needed from it — a named entry's bytes
+// and the list of entry names — so this reads the central directory and inflates
+// on demand rather than pulling in an archive library.
+
+function _findEndOfCentralDirectory(buf) {
+  // The record is 22 bytes plus a comment of up to 64 KiB, so it sits within the
+  // last 64 KiB + 22. Scanning backwards finds the real one before any earlier
+  // byte sequence that happens to look like the signature.
+  const min = Math.max(0, buf.length - (0xffff + 22));
+  for (let i = buf.length - 22; i >= min; i--) {
+    if (buf.readUInt32LE(i) === 0x06054b50) return i;
+  }
+  return -1;
+}
+
+// name → { method, compressedSize, size, localHeaderOffset }, in central
+// directory order.
+function readZipDirectory(buf) {
+  const eocd = _findEndOfCentralDirectory(buf);
+  if (eocd < 0) throw new Error('not a zip archive: no end-of-central-directory record');
+
+  let count  = buf.readUInt16LE(eocd + 10);
+  let offset = buf.readUInt32LE(eocd + 16);
+
+  // ZIP64: the 32-bit fields are saturated and the real ones live in the ZIP64
+  // record the locator points at. A WhatsApp APK is far from needing it, but an
+  // archive that does would otherwise be read as garbage rather than refused.
+  if (count === 0xffff || offset === 0xffffffff) {
+    const loc = eocd - 20;
+    if (loc < 0 || buf.readUInt32LE(loc) !== 0x07064b50) {
+      throw new Error('zip needs ZIP64 but carries no ZIP64 locator');
+    }
+    const z64 = Number(buf.readBigUInt64LE(loc + 8));
+    if (buf.readUInt32LE(z64) !== 0x06064b50) throw new Error('bad ZIP64 end-of-central-directory');
+    count  = Number(buf.readBigUInt64LE(z64 + 32));
+    offset = Number(buf.readBigUInt64LE(z64 + 48));
+  }
+
+  const entries = new Map();
+  let p = offset;
+  for (let i = 0; i < count; i++) {
+    if (buf.readUInt32LE(p) !== 0x02014b50) break;
+    const method         = buf.readUInt16LE(p + 10);
+    const compressedSize = buf.readUInt32LE(p + 20);
+    const size           = buf.readUInt32LE(p + 24);
+    const nameLen        = buf.readUInt16LE(p + 28);
+    const extraLen       = buf.readUInt16LE(p + 30);
+    const commentLen     = buf.readUInt16LE(p + 32);
+    const localHeaderOffset = buf.readUInt32LE(p + 42);
+    const name = buf.toString('utf8', p + 46, p + 46 + nameLen);
+    entries.set(name, { method, compressedSize, size, localHeaderOffset });
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+
+function readZipEntry(buf, entries, name) {
+  const e = entries.get(name);
+  if (!e) return null;
+  const lh = e.localHeaderOffset;
+  if (buf.readUInt32LE(lh) !== 0x04034b50) throw new Error('bad local header for ' + name);
+  // The local header's extra field is allowed to differ in length from the
+  // central directory's, so the data offset is computed from the local one.
+  const nameLen  = buf.readUInt16LE(lh + 26);
+  const extraLen = buf.readUInt16LE(lh + 28);
+  const start    = lh + 30 + nameLen + extraLen;
+  const raw      = buf.slice(start, start + e.compressedSize);
+  if (e.method === 0) return raw;
+  if (e.method === 8) return zlib.inflateRawSync(raw);
+  throw new Error('unsupported zip compression method ' + e.method + ' for ' + name);
+}
+
+// ─── DER / PKCS#7 ─────────────────────────────────────────────────────────────
+//
+// The signing certificates come out of the v1 (JAR) signature block, which is
+// what Cobalt reads — apk-parser's getApkSingers() is the v1 signer list. Only
+// enough DER is parsed to walk into SignedData and lift each certificate out
+// whole; nothing here validates a signature.
+
+function _readTlv(buf, pos) {
+  const tag = buf[pos];
+  let p = pos + 1;
+  let len = buf[p++];
+  if (len & 0x80) {
+    const n = len & 0x7f;
+    if (n === 0) throw new Error('indefinite DER length');
+    len = 0;
+    for (let i = 0; i < n; i++) len = (len << 8) | buf[p++];
+  }
+  return { tag, headerLength: p - pos, length: len, contentStart: p, end: p + len };
+}
+
+// Every certificate in a PKCS#7 SignedData, each as its own DER blob, in the
+// order the structure carries them.
+function certificatesFromPkcs7(der) {
+  const contentInfo = _readTlv(der, 0);                 // SEQUENCE
+  let p = contentInfo.contentStart;
+  const oid = _readTlv(der, p);                         // contentType OID
+  p = oid.end;
+  const explicit = _readTlv(der, p);                    // [0] EXPLICIT
+  const signedData = _readTlv(der, explicit.contentStart);
+
+  // SignedData ::= version, digestAlgorithms, contentInfo, [0] certificates …
+  let q = signedData.contentStart;
+  while (q < signedData.end) {
+    const field = _readTlv(der, q);
+    if (field.tag === 0xa0) {                           // [0] IMPLICIT certificates
+      const out = [];
+      let c = field.contentStart;
+      while (c < field.end) {
+        const cert = _readTlv(der, c);
+        if (cert.tag === 0x30) out.push(der.slice(c, cert.end));
+        c = cert.end;
+      }
+      return out;
+    }
+    q = field.end;
+  }
+  return [];
+}
+
+// ─── Binary AndroidManifest.xml ───────────────────────────────────────────────
+//
+// The manifest inside an APK is Android's binary XML, not text. Three things are
+// read out of it — the package name, the version name and the version code —
+// the same three Cobalt takes from its parsed manifest. The version name is the
+// one that matters most: the token is signed over this APK's classes.dex, so the
+// version announced to the server has to be this APK's, not whatever the Play
+// Store currently lists.
+//
+// Chunk layout is AOSP's ResourceTypes.h. Only what is needed to reach the
+// attributes of the first element is decoded.
+
+const _RES_STRING_POOL_TYPE     = 0x0001;
+const _RES_XML_START_ELEMENT    = 0x0102;
+const _UTF8_FLAG                = 0x0100;
+const _TYPE_STRING              = 0x03;
+
+function _readStringPool(buf, pos) {
+  const size        = buf.readUInt32LE(pos + 4);
+  const stringCount = buf.readUInt32LE(pos + 8);
+  const flags       = buf.readUInt32LE(pos + 16);
+  const stringsStart = buf.readUInt32LE(pos + 20);
+  const utf8 = (flags & _UTF8_FLAG) !== 0;
+
+  const strings = [];
+  for (let i = 0; i < stringCount; i++) {
+    const offset = buf.readUInt32LE(pos + 28 + i * 4);
+    let p = pos + stringsStart + offset;
+    if (p >= pos + size) { strings.push(''); continue; }
+    if (utf8) {
+      // Two lengths, characters then bytes, each one or two bytes wide.
+      let charLen = buf[p++];
+      if (charLen & 0x80) charLen = ((charLen & 0x7f) << 8) | buf[p++];
+      let byteLen = buf[p++];
+      if (byteLen & 0x80) byteLen = ((byteLen & 0x7f) << 8) | buf[p++];
+      strings.push(buf.toString('utf8', p, p + byteLen));
+    } else {
+      let len = buf.readUInt16LE(p); p += 2;
+      if (len & 0x8000) { len = ((len & 0x7fff) << 16) | buf.readUInt16LE(p); p += 2; }
+      strings.push(buf.toString('utf16le', p, p + len * 2));
+    }
+  }
+  return strings;
+}
+
+/**
+ * { packageName, versionName, versionCode } out of a binary AndroidManifest.xml.
+ * Any field the manifest does not carry comes back null.
+ */
+function parseManifest(buf) {
+  const empty = { packageName: null, versionName: null, versionCode: null };
+  if (!buf || buf.length < 8) return empty;
+
+  let strings = null;
+  let pos = 8;                                     // past the file's own chunk header
+  while (pos + 8 <= buf.length) {
+    const type      = buf.readUInt16LE(pos);
+    const chunkSize = buf.readUInt32LE(pos + 4);
+    if (chunkSize <= 0 || pos + chunkSize > buf.length) break;
+
+    if (type === _RES_STRING_POOL_TYPE) {
+      strings = _readStringPool(buf, pos);
+    } else if (type === _RES_XML_START_ELEMENT && strings) {
+      // ResXMLTree_node (8 bytes) then ResXMLTree_attrExt.
+      const ext            = pos + 16;
+      const nameIndex      = buf.readUInt32LE(ext + 4);
+      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;
+      }
+      return out;
+    }
+    pos += chunkSize;
+  }
+  return empty;
+}
+
+// A split's own name, as Android files it: "config.xxhdpi" out of
+// "base-config.xxhdpi.apk" or "split_config.xxhdpi.apk". Cobalt only searches
+// splits whose name ends in "dpi", which is the density-qualified set.
+function _isDensitySplit(fileName) {
+  const base = String(fileName).replace(/\.apk$/i, '');
+  return /dpi$/i.test(base);
+}
+
+/**
+ * Read the token material out of a WhatsApp APK.
+ *
+ * base:   Buffer with the base APK.
+ * splits: optional [{ name, data }] for the density splits, searched only when
+ *         the base APK does not carry about_logo.png — which is the case for
+ *         every App Bundle release.
+ *
+ * Returns { packageName, secretKey, classesDexMd5, certificates } with the
+ * three derived pieces as Buffers, ready for computeToken.
+ */
+function extractMaterial(base, splits) {
+  const entries = readZipDirectory(base);
+
+  let aboutLogo = null;
+  for (const p of ABOUT_LOGO_PATHS) {
+    aboutLogo = readZipEntry(base, entries, p);
+    if (aboutLogo) break;
+  }
+  if (!aboutLogo) {
+    for (const split of (splits || [])) {
+      if (!_isDensitySplit(split.name)) continue;
+      const sEntries = readZipDirectory(split.data);
+      for (const p of ABOUT_LOGO_PATHS) {
+        aboutLogo = readZipEntry(split.data, sEntries, p);
+        if (aboutLogo) break;
+      }
+      if (aboutLogo) break;
+    }
+  }
+  if (!aboutLogo) {
+    throw new Error('about_logo.png is in neither the base APK nor any density split — ' +
+      'pass the split APKs alongside the base one (' + ABOUT_LOGO_PATHS.join(', ') + ')');
+  }
+
+  const classesDex = readZipEntry(base, entries, 'classes.dex');
+  if (!classesDex) throw new Error('classes.dex missing from the base APK');
+
+  const certificates = [];
+  for (const name of entries.keys()) {
+    if (!/^META-INF\/[^/]+\.(RSA|DSA|EC)$/i.test(name)) continue;
+    for (const cert of certificatesFromPkcs7(readZipEntry(base, entries, name))) {
+      certificates.push(cert);
+    }
+  }
+  if (!certificates.length) {
+    throw new Error('no v1 signing certificate in META-INF — this APK is not JAR-signed, ' +
+      'and the token is built from the v1 signature block');
+  }
+
+  const manifest    = parseManifest(readZipEntry(base, entries, 'AndroidManifest.xml'));
+  const packageName = manifest.packageName || PERSONAL_PACKAGE;
+
+  return {
+    packageName,
+    secretKey:     deriveSecretKey(packageName, aboutLogo),
+    classesDexMd5: crypto.createHash('md5').update(classesDex).digest(),
+    certificates,
+    // The version this APK is. Announced instead of the live one, because the
+    // token is signed over this build's classes.dex.
+    apkVersion:     manifest.versionName,
+    apkVersionCode: manifest.versionCode
+  };
+}
+
+// PBKDF2-HMAC-SHA1 over the package name followed by the raw PNG bytes.
+//
+// Cobalt runs the derivation by hand because the JCA factory rejects a binary
+// password; the loop it runs is standard PBKDF2, so this calls the platform's.
+// The two are checked against each other in the token test.
+function deriveSecretKey(packageName, aboutLogo) {
+  const password = Buffer.concat([Buffer.from(packageName, 'utf8'), aboutLogo]);
+  return crypto.pbkdf2Sync(password, ANDROID_SALT, PBKDF2_ITERATIONS, PBKDF2_KEY_SIZE, 'sha1');
+}
+
+/**
+ * The registration token for a national number, as the Android client signs it.
+ *
+ * material: as returned by extractMaterial (or loaded from its JSON form).
+ * national: the number without the country code, digits only.
+ */
+function computeToken(material, national) {
+  const mac = crypto.createHmac('sha1', material.secretKey);
+  for (const cert of material.certificates) mac.update(cert);
+  mac.update(material.classesDexMd5);
+  mac.update(Buffer.from(String(national), 'utf8'));
+  // Java's URLEncoder over base64: '+', '/' and '=' are the only characters it
+  // touches, and encodeURIComponent escapes those three identically.
+  return encodeURIComponent(mac.digest().toString('base64'));
+}
+
+// ─── Storage ──────────────────────────────────────────────────────────────────
+//
+// Only the derived pieces are kept, the way Cobalt caches them — the APK itself
+// is never needed again.
+
+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
+  };
+}
+
+function materialFromJson(json) {
+  if (!json || !json.secretKey || !json.classesDexMd5 || !Array.isArray(json.certificates)) {
+    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
+  };
+}
+
+module.exports = {
+  extractMaterial,
+  parseManifest,
+  deriveSecretKey,
+  computeToken,
+  materialToJson,
+  materialFromJson,
+  certificatesFromPkcs7,
+  readZipDirectory,
+  readZipEntry,
+  ANDROID_SALT,
+  ABOUT_LOGO_PATHS,
+  PERSONAL_PACKAGE,
+  BUSINESS_PACKAGE
+};

package/lib/Registration.js

@@ -3,9 +3,13 @@
 const crypto = require('crypto');
 const https  = require('https');
 const tls    = require('tls');
+const fs     = require('fs');
+const os     = require('os');
+const path   = require('path');
 const curveJs = require('curve25519-js');
 const { v4: uuidv4 } = require('uuid');
 const { getDeviceConfig } = require('./DeviceConfig');
+const AndroidApk  = require('./AndroidApk');
 const attestation = require('./Attestation');
 const { dbg: _whaDbg } = require('./logger');
 
@@ -311,7 +315,6 @@ const {
   REGISTRATION_ENDPOINT,
   REGISTRATION_PUBLIC_KEY,
   IOS_STATIC_TOKEN,
-  ANDROID_STATIC_TOKEN,
   IOS_VERSION_FALLBACK,
   ANDROID_VERSION_FALLBACK,
   IOS_USER_AGENT,
@@ -523,20 +526,78 @@ async function fetchAndroidVersion() {
 
 // Return the appropriate WhatsApp version for the active device.
 // If WA_VERSION is set in the environment, that value is always used.
+//
+// On Android the APK the token material came from decides it, the way Cobalt
+// announces the versionName of the APK it downloaded. The token is signed over
+// that build's classes.dex, so a version read from anywhere else describes a
+// different build than the one the token proves — which the server sees as a
+// token that does not belong to the client sending it. The live lookup stays as
+// the fallback for when there is no material yet.
 async function fetchWaVersion(device) {
   if (process.env.WA_VERSION) return process.env.WA_VERSION;
-  return (device && device.os === 'android') ? fetchAndroidVersion() : fetchIosVersion();
+  if (device && device.os === 'android') {
+    const material = tryLoadAndroidMaterial();
+    if (material && material.apkVersion) return material.apkVersion;
+    return fetchAndroidVersion();
+  }
+  return fetchIosVersion();
 }
 
 // ---------- Token computation ----------
-// token = MD5( staticToken + MD5hex(waVersion) + nationalNumber )
-// The static token depends on the platform (iOS vs Android).
-// Override with WA_STATIC_TOKEN in .env if the bundled token becomes stale.
+//
+// The two platforms compute this differently, and only iOS derives it from a
+// static string:
+//
+//   iOS      MD5( staticToken + MD5hex(waVersion) + nationalNumber )
+//   Android  HMAC-SHA1, keyed by material taken out of the APK, over the
+//            signing certificates, MD5(classes.dex) and the national number
+//
+// Android was being sent the iOS calculation with a different constant put in
+// front of it. No such constant exists — the Android client signs the token
+// with its own APK — and the server answered every attempt with bad_token. See
+// AndroidApk.js for the algorithm and where the material comes from.
+//
+// WA_STATIC_TOKEN therefore only means anything on iOS. It cannot substitute
+// for the Android material, so it is deliberately not consulted there.
+
+// Where the extracted Android material is kept. Beside the sessions by default,
+// since that is the directory the CLI already owns.
+function androidMaterialPath() {
+  return process.env.WA_ANDROID_APK_MATERIAL ||
+    path.join(os.homedir(), '.waSession', 'android-apk-material.json');
+}
+
+let _androidMaterial = null;
+
+// The material if there is any, without insisting on it. fetchWaVersion asks
+// this way: a missing file is the token's problem to report, not the version's.
+function tryLoadAndroidMaterial() {
+  try { return loadAndroidMaterial(); } catch (_) { return null; }
+}
+
+function loadAndroidMaterial() {
+  if (_androidMaterial) return _androidMaterial;
+  const file = androidMaterialPath();
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch (_) {
+    throw new Error('registering as Android needs the token material from a WhatsApp APK, ' +
+      'and there is none at ' + file + '. Extract it once per WhatsApp release with:\n' +
+      '  wa apk-material <base.apk> [split.apk ...]\n' +
+      'Pull the APK off a phone or emulator that has WhatsApp installed (adb), or point ' +
+      'WA_ANDROID_APK_MATERIAL at a file you already have. Registering as iOS needs none of this.');
+  }
+  _androidMaterial = AndroidApk.materialFromJson(JSON.parse(raw));
+  return _androidMaterial;
+}
 
 function computeToken(waVersion, national) {
-  const device      = getDeviceConfig();
-  const staticToken = process.env.WA_STATIC_TOKEN
-    || (device.os === 'android' ? ANDROID_STATIC_TOKEN : IOS_STATIC_TOKEN);
+  const device = getDeviceConfig();
+  if (device.os === 'android') {
+    return AndroidApk.computeToken(loadAndroidMaterial(), national);
+  }
+  const staticToken    = process.env.WA_STATIC_TOKEN || IOS_STATIC_TOKEN;
   const versionHashHex = md5Bytes(waVersion).toString('hex');
   return md5Hex(staticToken + versionHashHex + national);
 }
@@ -1399,6 +1460,9 @@ module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyC
 // The HTTP reader, exposed for tests. Not part of the public API.
 module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody };
 
+// Token computation, exposed for tests. Not part of the public API.
+module.exports._token = { computeToken, androidMaterialPath, registrationHeaders };
+
 // Challenge / two-factor internals, exposed for tests. Not part of the public API.
 module.exports._verify = {
   hasChallenge, is2FARequired, decodeOrNull, isSuccessful,

package/lib/constants.js

@@ -31,11 +31,15 @@ const WEB_VERSION_FALLBACK = [2, 3000, 1035194821];
 // the name the account owner sees in the linked-devices list on their phone.
 const WEB_BROWSER = ['Ubuntu', 'Chrome', '120.0.0.0'];
 
-// Static tokens used in WhatsApp registration token computation.
+// Static tokens used in the iOS registration token computation.
 // token = MD5( staticToken + MD5hex(waVersion) + nationalNumber )
+//
+// iOS only. Android has no static token at all — it signs the token with
+// material out of its own APK (see AndroidApk.js), and the value that used to
+// sit here as ANDROID_STATIC_TOKEN was this same iOS calculation with an
+// invented constant in front of it, which the server refused as bad_token.
 const IOS_STATIC_TOKEN          = '0a1mLfGUIBVrMKF1RdvLI5lkRBvof6vn0fD2QRSM';
 const IOS_BUSINESS_STATIC_TOKEN = 'USUDuDYDeQhY4RF2fCSp5m3F6kJ1M2J8wS7bbNA2';
-const ANDROID_STATIC_TOKEN      = 'Y29Cs6AVNR2bj5PBeKSYFd1nAKuvNQ3h';
 
 // WhatsApp version fallbacks — used when live fetch fails.
 const IOS_VERSION_FALLBACK     = '2.26.9.75';
@@ -228,7 +232,6 @@ module.exports = {
   WEB_BROWSER,
   IOS_STATIC_TOKEN,
   IOS_BUSINESS_STATIC_TOKEN,
-  ANDROID_STATIC_TOKEN,
   IOS_VERSION_FALLBACK,
   ANDROID_VERSION_FALLBACK,
   IOS_USER_AGENT,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.12.10",
+  "version": "5.12.11",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto20",
   "main": "index.js",