whalibmob 5.12.10 → 5.12.13

package/lib/PlayStore.js

@@ -0,0 +1,381 @@
+'use strict';
+
+// Fetching the WhatsApp APK from Google Play, the way Cobalt's PlayStoreUtils
+// does it, so the Android token material can be refreshed without anyone having
+// to find an APK by hand.
+//
+// The route, in three hops:
+//
+//   1. POST an Aurora-style device profile to the Aurora OSS token dispenser,
+//      which mints an anonymous Google account and hands back a Play auth token
+//      plus the device metadata that has to accompany it. No Google account of
+//      the caller's is involved at any point.
+//   2. GET /fdfe/details for the version, then /fdfe/purchase to acquire the
+//      free app, then /fdfe/delivery for the signed CDN URLs. All three answer
+//      in protobuf.
+//   3. GET each URL with the delivery cookies attached, which yields the base
+//      APK and every split.
+//
+// Two things are worth knowing before relying on this. The dispenser is a free
+// third-party service — when it is down or rate limited, so is this, and the
+// APK on a phone is always available where this is not. And a current WhatsApp
+// bundle is well over a hundred megabytes across its splits, which is a real
+// download on a phone connection; only the density splits are actually needed
+// for the token, so this fetches only those.
+
+const https = require('https');
+const { URL } = require('url');
+const DEVICE_PROFILE = require('./playstore-device');
+const { dbg: _whaDbg } = require('./logger');
+
+const AURORA_DISPENSER_URL = 'https://auroraoss.com/api/auth';
+// The dispenser refuses a request with an arbitrary user-agent.
+const AURORA_USER_AGENT    = 'com.aurora.store-4.6.1-70';
+
+const FDFE_BASE_URL = 'https://android.clients.google.com/fdfe';
+const DETAILS_URL   = FDFE_BASE_URL + '/details';
+const PURCHASE_URL  = FDFE_BASE_URL + '/purchase';
+const DELIVERY_URL  = FDFE_BASE_URL + '/delivery';
+
+// Which Play protocol features the client claims to understand. The same blob
+// gplaydl and the Aurora Store ship; required on every FDFE call.
+const X_DFE_ENCODED_TARGETS =
+  'CAESN/qigQYC2AMBFfUbyA7SM5Ij/CvfBoIDgxXrBPsDlQUdMfOLAfoFrwEHgAcBrQYhoA0cGt4MKK0Y2gI';
+
+const FALLBACK_FINSKY_USER_AGENT =
+  'Android-Finsky/41.2.29-23 [0] [PR] 639844241 ' +
+  '(api=3,versionCode=84122900,sdk=34,device=lynx,' +
+  'hardware=lynx,product=lynx,platformVersionRelease=14,' +
+  'model=Pixel%207a,buildId=UQ1A.231205.015,' +
+  'isWideScreen=0,supportedAbis=arm64-v8a;armeabi-v7a;armeabi)';
+
+const LOCALE          = 'en_US';
+const REQUEST_TIMEOUT = 120000;
+
+const PERSONAL_PACKAGE = 'com.whatsapp';
+
+// ─── protobuf ─────────────────────────────────────────────────────────────────
+//
+// Only enough of the wire format to walk to a handful of known fields. Every
+// message here is read by field number, and anything unrecognised is skipped —
+// which is most of what Play returns.
+
+function _readVarint(buf, pos) {
+  let result = 0, shift = 0, byte;
+  do {
+    if (pos >= buf.length) throw new Error('truncated varint');
+    byte = buf[pos++];
+    result += (byte & 0x7f) * Math.pow(2, shift);
+    shift += 7;
+  } while (byte & 0x80);
+  return { value: result, pos };
+}
+
+// field number → array of values. Length-delimited fields come back as Buffers,
+// varints as numbers; everything else is skipped.
+function decodeFields(buf) {
+  const out = new Map();
+  let pos = 0;
+  while (pos < buf.length) {
+    let key;
+    try { ({ value: key, pos } = _readVarint(buf, pos)); } catch (_) { break; }
+    const field    = Math.floor(key / 8);
+    const wireType = key & 7;
+    let value;
+    if (wireType === 0) {
+      ({ value, pos } = _readVarint(buf, pos));
+    } else if (wireType === 2) {
+      let len;
+      ({ value: len, pos } = _readVarint(buf, pos));
+      if (pos + len > buf.length) break;
+      value = buf.slice(pos, pos + len);
+      pos += len;
+    } else if (wireType === 5) {
+      value = buf.readUInt32LE(pos); pos += 4;
+    } else if (wireType === 1) {
+      value = buf.slice(pos, pos + 8); pos += 8;
+    } else {
+      break;                              // groups: not used by these messages
+    }
+    if (!out.has(field)) out.set(field, []);
+    out.get(field).push(value);
+  }
+  return out;
+}
+
+function _one(fields, n) {
+  const v = fields && fields.get(n);
+  return v && v.length ? v[0] : null;
+}
+
+// Walk a chain of message field numbers, e.g. msg(1).msg(2).msg(21).
+function _walk(buf, path) {
+  let cur = buf;
+  for (const n of path) {
+    const next = _one(decodeFields(cur), n);
+    if (next === null || !Buffer.isBuffer(next)) return null;
+    cur = next;
+  }
+  return cur;
+}
+
+// ─── HTTP ─────────────────────────────────────────────────────────────────────
+
+function _request(url, opts) {
+  opts = opts || {};
+  return new Promise((resolve, reject) => {
+    const u   = new URL(url);
+    const req = https.request({
+      hostname: u.hostname,
+      port:     u.port || 443,
+      path:     u.pathname + u.search,
+      method:   opts.method || 'GET',
+      headers:  opts.headers || {},
+      timeout:  REQUEST_TIMEOUT
+    }, (res) => {
+      // The CDN answers a signed URL with a redirect more often than not.
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location &&
+          (opts.redirects || 0) < 5) {
+        res.resume();
+        return resolve(_request(new URL(res.headers.location, url).toString(),
+          Object.assign({}, opts, { redirects: (opts.redirects || 0) + 1 })));
+      }
+      const chunks = [];
+      res.on('data', d => chunks.push(d));
+      res.on('end', () => resolve({ status: res.statusCode, body: Buffer.concat(chunks) }));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('timeout on ' + url)));
+    if (opts.body) req.write(opts.body);
+    req.end();
+  });
+}
+
+// ─── Auth ─────────────────────────────────────────────────────────────────────
+
+async function fetchAnonymousAuth() {
+  const body = JSON.stringify(DEVICE_PROFILE);
+  const res  = await _request(AURORA_DISPENSER_URL, {
+    method:  'POST',
+    headers: {
+      'Content-Type':   'application/json',
+      'User-Agent':     AURORA_USER_AGENT,
+      'Content-Length': Buffer.byteLength(body)
+    },
+    body
+  });
+  if (res.status !== 200) {
+    throw new Error('the Aurora token dispenser answered HTTP ' + res.status +
+      ' — it is a free third-party service and this is what it does when it is ' +
+      'down or rate limiting. Nothing is wrong with your setup; either try again ' +
+      'later or pass an APK path instead.');
+  }
+
+  let json;
+  try { json = JSON.parse(res.body.toString('utf8')); }
+  catch (_) { throw new Error('the Aurora token dispenser returned something that is not JSON'); }
+  if (!json || !json.authToken) {
+    throw new Error('the Aurora token dispenser returned no authToken');
+  }
+
+  const provider = json.deviceInfoProvider || {};
+  return {
+    authToken:  json.authToken,
+    gsfId:      json.gsfId    || '',
+    dfeCookie:  json.dfeCookie || '',
+    checkinConsistencyToken: json.deviceCheckInConsistencyToken || null,
+    deviceConfigToken:       json.deviceConfigToken || null,
+    userAgent:  provider.userAgentString || FALLBACK_FINSKY_USER_AGENT,
+    mccMnc:     provider.mccMnc || null
+  };
+}
+
+function buildFdfeHeaders(auth) {
+  const headers = {
+    'Authorization':               'Bearer ' + auth.authToken,
+    'User-Agent':                  auth.userAgent,
+    'X-DFE-Device-Id':             auth.gsfId,
+    'Accept-Language':             'en-US',
+    'X-DFE-Encoded-Targets':       X_DFE_ENCODED_TARGETS,
+    'X-DFE-Client-Id':             'am-android-google',
+    'X-DFE-Network-Type':          '4',
+    'X-DFE-Content-Filters':       '',
+    'X-Limit-Ad-Tracking-Enabled': 'false',
+    'X-Ad-Id':                     '',
+    'X-DFE-UserLanguages':         LOCALE,
+    'X-DFE-Request-Params':        'timeoutMs=4000',
+    'X-DFE-Cookie':                auth.dfeCookie,
+    'X-DFE-No-Prefetch':           'true'
+  };
+  if (auth.checkinConsistencyToken) headers['X-DFE-Device-Checkin-Consistency-Token'] = auth.checkinConsistencyToken;
+  if (auth.deviceConfigToken)       headers['X-DFE-Device-Config-Token']              = auth.deviceConfigToken;
+  if (auth.mccMnc)                  headers['X-DFE-MCCMNC']                           = auth.mccMnc;
+  return headers;
+}
+
+async function _protoGet(url, headers) {
+  const res = await _request(url, {
+    headers: Object.assign({
+      'Content-Type': 'application/x-protobuf',
+      'Accept':       'application/x-protobuf'
+    }, headers)
+  });
+  if (res.status !== 200) throw new Error('GET ' + url + ' returned HTTP ' + res.status);
+  return res.body;
+}
+
+// ─── Catalogue ────────────────────────────────────────────────────────────────
+
+// { versionCode, versionName } for a package, without downloading anything.
+async function fetchVersion(packageName, headers) {
+  const raw = await _protoGet(DETAILS_URL + '?doc=' + encodeURIComponent(packageName), headers);
+  // ResponseWrapper(1).Payload → detailsResponse(2).docV2(4).docDetails(13).appDetails(1)
+  const details = _walk(raw, [1, 2, 4, 13, 1]);
+  if (!details) throw new Error('the Play details response carried no AppDetails for ' + packageName);
+  const fields = decodeFields(details);
+  const code   = _one(fields, 3);
+  const name   = _one(fields, 4);
+  if (code === null) throw new Error('the Play details response carried no versionCode for ' + packageName);
+  return { versionCode: code, versionName: name ? name.toString('utf8') : '' };
+}
+
+// The "Install" button. An app already associated with the rotated account
+// answers 4xx, and the download works regardless, so failures are ignored.
+async function acquire(packageName, versionCode, headers) {
+  const body = 'doc=' + encodeURIComponent(packageName) + '&ot=1&vc=' + versionCode;
+  try {
+    await _request(PURCHASE_URL, {
+      method: 'POST',
+      headers: Object.assign({
+        'Content-Type':   'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(body)
+      }, headers),
+      body
+    });
+  } catch (_) { /* best effort, as in Cobalt */ }
+}
+
+// { baseUrl, splits: [{name, url}], cookies: {name: value} }
+async function fetchDelivery(packageName, versionCode, headers) {
+  const raw = await _protoGet(
+    DELIVERY_URL + '?doc=' + encodeURIComponent(packageName) + '&ot=1&vc=' + versionCode,
+    headers);
+  // ResponseWrapper(1).Payload → deliveryResponse(21).appDeliveryData(2)
+  const data = _walk(raw, [1, 21, 2]);
+  if (!data) throw new Error('the Play delivery response carried no AppDeliveryData for ' + packageName);
+
+  const fields  = decodeFields(data);
+  const baseUrl = _one(fields, 3);
+  if (!baseUrl || !baseUrl.length) {
+    throw new Error('Play issued no download URL for ' + packageName +
+      ' — the app is unavailable for this synthetic device profile');
+  }
+
+  const splits = [];
+  for (const s of (fields.get(15) || [])) {
+    const sf   = decodeFields(s);
+    const name = _one(sf, 1);
+    const url  = _one(sf, 5);
+    if (!url || !url.length) continue;
+    splits.push({
+      name: name ? name.toString('utf8') : 'split-' + splits.length,
+      url:  url.toString('utf8')
+    });
+  }
+
+  // Tag 4 is overloaded: cookies and OBB metadata share it. A cookie starts with
+  // the tag byte for a length-delimited field 1 (its name), which is what tells
+  // the two apart.
+  const cookies = {};
+  for (const entry of (fields.get(4) || [])) {
+    if (!entry.length || entry[0] !== 0x0a) continue;
+    const cf    = decodeFields(entry);
+    const name  = _one(cf, 1);
+    const value = _one(cf, 2);
+    if (!name || !name.length) continue;
+    cookies[name.toString('utf8')] = value ? value.toString('utf8') : '';
+  }
+
+  return { baseUrl: baseUrl.toString('utf8'), splits, cookies };
+}
+
+async function _download(url, cookies) {
+  const headers = {};
+  const pairs   = Object.keys(cookies || {}).map(k => k + '=' + cookies[k]);
+  if (pairs.length) headers.Cookie = pairs.join('; ');
+  const res = await _request(url, { headers });
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error('APK download failed with HTTP ' + res.status);
+  }
+  return res.body;
+}
+
+/**
+ * Download what the Android token material needs from Play.
+ *
+ * Returns { packageName, versionCode, versionName, base, splits: [{name,data}] }
+ * with the APK bytes in hand.
+ *
+ * Only the density splits are fetched. The token's key comes from
+ * about_logo.png, which lives in one of those; the architecture and language
+ * splits are a hundred megabytes that nothing here would ever read. Pass
+ * { allSplits: true } to take everything anyway.
+ */
+async function downloadApk(opts) {
+  opts = opts || {};
+  const packageName = opts.packageName || PERSONAL_PACKAGE;
+
+  _whaDbg('[DBG] PLAY → dispenser');
+  const auth    = await fetchAnonymousAuth();
+  const headers = buildFdfeHeaders(auth);
+
+  _whaDbg('[DBG] PLAY → details ' + packageName);
+  const version = await fetchVersion(packageName, headers);
+  if (opts.onProgress) opts.onProgress('version ' + version.versionName + ' (code ' + version.versionCode + ')');
+
+  await acquire(packageName, version.versionCode, headers);
+
+  _whaDbg('[DBG] PLAY → delivery ' + packageName + ' vc=' + version.versionCode);
+  const delivery = await fetchDelivery(packageName, version.versionCode, headers);
+
+  const wanted = opts.allSplits
+    ? delivery.splits
+    : delivery.splits.filter(s => /dpi$/i.test(String(s.name).replace(/\.apk$/i, '')));
+
+  // Which densities came back is worth saying out loud. Play serves the splits
+  // that suit the device profile it was asked as, not the full set a bundle
+  // holds, so the about_logo.png this yields can be a different density from
+  // the one in a complete bundle — and a different density is a different key.
+  if (opts.onProgress) {
+    opts.onProgress('downloading base.apk and ' + wanted.length + ' density split' +
+      (wanted.length === 1 ? '' : 's') +
+      ' (of ' + delivery.splits.length + ' the server offered): ' +
+      (wanted.map(s => s.name).join(', ') || 'none'));
+  }
+
+  const base = await _download(delivery.baseUrl, delivery.cookies);
+  const splits = [];
+  for (const s of wanted) {
+    if (opts.onProgress) opts.onProgress('  ' + s.name);
+    splits.push({ name: s.name, data: await _download(s.url, delivery.cookies) });
+  }
+
+  return {
+    packageName,
+    versionCode: version.versionCode,
+    versionName: version.versionName,
+    base,
+    splits
+  };
+}
+
+module.exports = {
+  downloadApk,
+  fetchAnonymousAuth,
+  buildFdfeHeaders,
+  fetchVersion,
+  fetchDelivery,
+  decodeFields,
+  AURORA_DISPENSER_URL,
+  PERSONAL_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,162 @@ 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; }
+}
+
+/**
+ * Have the Android token material ready, fetching the APK if it is not.
+ *
+ * Registering as Android cannot produce a token without material read out of a
+ * WhatsApp APK, and that material goes stale on every WhatsApp release. Asking
+ * the caller to go and find an APK first turns one command into a chore, so a
+ * registration that finds none fetches one from Play itself and carries on.
+ *
+ * Only a *missing* file is answered this way. An APK that turns out to be a
+ * repack is refused as it was before — downloading over somebody's deliberate
+ * choice of APK would be the wrong way to be helpful.
+ *
+ * A no-op on iOS, and WA_NO_APK_DOWNLOAD=1 turns it off for anyone who would
+ * rather a hundred megabytes were never fetched without being asked for.
+ */
+async function ensureAndroidMaterial(opts) {
+  opts = opts || {};
+  const device = getDeviceConfig();
+  if (device.os !== 'android') return null;
+
+  try {
+    return loadAndroidMaterial();
+  } catch (err) {
+    if (err.code !== 'NO_APK_MATERIAL') throw err;
+    if (process.env.WA_NO_APK_DOWNLOAD === '1') throw err;
+  }
+
+  const say = opts.onProgress || (m => _whaDbg('[DBG] APK ' + m));
+  const AndroidApk = require('./AndroidApk');
+  const PlayStore  = require('./PlayStore');
+
+  say('no Android token material yet — fetching the WhatsApp APK from Google Play');
+  let apk;
+  try {
+    apk = await PlayStore.downloadApk({ onProgress: m => say('  ' + m) });
+  } catch (err) {
+    throw new Error('could not fetch the WhatsApp APK automatically: ' + err.message +
+      '\nRead it out of an APK you have instead:\n' +
+      '  wa apk-material <base.apk> [split.apk ...]');
+  }
+
+  const material = AndroidApk.extractMaterial(apk.base, apk.splits);
+  if (!material.apkVersion)     material.apkVersion     = apk.versionName;
+  if (!material.apkVersionCode) material.apkVersionCode = apk.versionCode;
+
+  const file = androidMaterialPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(AndroidApk.materialToJson(material), null, 2));
+  say('  token material written to ' + file);
+
+  // Re-read it rather than using what is in hand, so the downloaded APK goes
+  // through the same signature check as one that was already on disk.
+  _androidMaterial = null;
+  return loadAndroidMaterial();
+}
+
+function loadAndroidMaterial() {
+  if (_androidMaterial) return _androidMaterial;
+  const file = androidMaterialPath();
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch (_) {
+    const err = new Error('registering as Android needs the token material from a WhatsApp APK, ' +
+      'and there is none at ' + file + '. Fetch it with:\n' +
+      '  wa apk-material --download\n' +
+      'or read it out of an APK you already have:\n' +
+      '  wa apk-material <base.apk> [split.apk ...]\n' +
+      'Registering as iOS needs none of this.');
+    // Told apart from a refused repack, which must never be answered by
+    // downloading over it.
+    err.code = 'NO_APK_MATERIAL';
+    throw err;
+  }
+  const material = AndroidApk.materialFromJson(JSON.parse(raw));
+
+  // Refuse a repack before anything is sent.
+  //
+  // The token is an HMAC over the APK's signing certificates. An APK a mirror
+  // re-signed — commonly with the AOSP test key, whose private half ships in the
+  // Android sources — produces a well-formed token that belongs to nobody, and
+  // the server answers bad_token, exactly as it does when there is no material
+  // at all. Left to run, that spends /code attempts against a real phone number
+  // on a request that cannot succeed, and attempts are what gets a number rate
+  // limited. Checking the subject costs nothing and is the difference between a
+  // refusal here and a number burned.
+  const signer = AndroidApk.describeCertificate(material.certificates[0]);
+  if (signer && !AndroidApk.looksLikeWhatsAppCertificate(signer) &&
+      process.env.WA_ALLOW_FOREIGN_APK !== '1') {
+    throw new Error('the APK this token material came from was not signed by WhatsApp — ' +
+      'it is signed by "' + signer.subject.replace(/\n/g, ', ') + '". Re-signing replaces ' +
+      'the certificate the token is built from, so every attempt would come back as ' +
+      'bad_token. Take the APK from a phone that has WhatsApp installed:\n' +
+      '  pm path com.whatsapp\n' +
+      'then re-run wa apk-material with it. Set WA_ALLOW_FOREIGN_APK=1 to send it anyway.');
+  }
+
+  _androidMaterial = material;
+  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);
 }
@@ -1186,6 +1331,9 @@ async function assertRegistrationKeys(store, waVersion) {
 async function requestSmsCode(store, method, opts) {
   method = method || 'sms';
   opts   = opts   || {};
+  // Before the version is read, since on Android the version comes out of the
+  // APK this fetches.
+  await ensureAndroidMaterial(opts);
   const _device   = getDeviceConfig();
   const waVersion = await fetchWaVersion(_device);
   store.version = waVersion;
@@ -1305,6 +1453,9 @@ async function requestSmsCode(store, method, opts) {
 
 async function verifyCode(store, code, opts) {
   opts = opts || {};
+  // Normally already there from the code request, but a confirmation can be run
+  // from a fresh shell that never made one.
+  await ensureAndroidMaterial(opts);
   const _device   = getDeviceConfig();
   const waVersion = await fetchWaVersion(_device);
   store.version = waVersion;
@@ -1399,6 +1550,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, ensureAndroidMaterial };
+
 // 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/lib/playstore-device.js

@@ -0,0 +1,45 @@
+// Aurora-style device profile posted to the anonymous token dispenser.
+// Copied verbatim from Cobalt's sdk-gphone64-x86_64.json — the dispenser
+// mints an account shaped for this device, and the Play catalogue decides
+// what it is allowed to download from it.
+
+'use strict';
+
+module.exports = {
+  "HasHardKeyboard": "true",
+  "Build.HARDWARE": "ranchu",
+  "Build.BRAND": "google",
+  "Build.VERSION.SDK_INT": "33",
+  "Roaming": "mobile-notroaming",
+  "Build.MODEL": "sdk_gphone64_x86_64",
+  "Vending.versionString": "51.0.19-31 [0] [PR] 897988648",
+  "Vending.version": "85101930",
+  "CellOperator": "310",
+  "Build.FINGERPRINT": "google/sdk_gphone64_x86_64/emu64x:13/TE1A.240213.009/12342917:user/release-keys",
+  "Build.DEVICE": "emu64x",
+  "Screen.Height": "3120",
+  "SimOperator": "260",
+  "ScreenLayout": "2",
+  "SharedLibraries": "android.ext.shared,android.hidl.base-V1.0-java,android.hidl.manager-V1.0-java,android.net.ipsec.ike,android.test.base,android.test.mock,android.test.runner,androidx.window.extensions,androidx.window.sidecar,com.android.cts.ctsshim.shared_library,com.android.future.usb.accessory,com.android.location.provider,com.android.media.remotedisplay,com.android.mediadrm.signer,com.android.nfc_extras,com.google.android.dialer.support,com.google.android.gms,com.google.android.trichromelibrary,javax.obex,org.apache.http.legacy",
+  "Features": "android.hardware.audio.output,android.hardware.bluetooth,android.hardware.bluetooth_le,android.hardware.camera,android.hardware.camera.any,android.hardware.camera.ar,android.hardware.camera.autofocus,android.hardware.camera.capability.manual_post_processing,android.hardware.camera.capability.manual_sensor,android.hardware.camera.capability.raw,android.hardware.camera.concurrent,android.hardware.camera.flash,android.hardware.camera.front,android.hardware.camera.level.full,android.hardware.faketouch,android.hardware.fingerprint,android.hardware.hardware_keystore,android.hardware.identity_credential,android.hardware.keystore.app_attest_key,android.hardware.location,android.hardware.location.gps,android.hardware.location.network,android.hardware.microphone,android.hardware.ram.normal,android.hardware.screen.landscape,android.hardware.screen.portrait,android.hardware.security.model.compatible,android.hardware.sensor.accelerometer,android.hardware.sensor.ambient_temperature,android.hardware.sensor.barometer,android.hardware.sensor.compass,android.hardware.sensor.gyroscope,android.hardware.sensor.hinge_angle,android.hardware.sensor.light,android.hardware.sensor.proximity,android.hardware.sensor.relative_humidity,android.hardware.telephony,android.hardware.telephony.data,android.hardware.telephony.gsm,android.hardware.telephony.ims,android.hardware.telephony.radio.access,android.hardware.telephony.subscription,android.hardware.touchscreen,android.hardware.touchscreen.multitouch,android.hardware.touchscreen.multitouch.distinct,android.hardware.touchscreen.multitouch.jazzhand,android.hardware.vulkan.compute,android.hardware.vulkan.level,android.hardware.vulkan.version,android.hardware.wifi,android.hardware.wifi.direct,android.hardware.wifi.passpoint,android.software.activities_on_secondary_displays,android.software.adoptable_storage,android.software.app_enumeration,android.software.app_widgets,android.software.autofill,android.software.backup,android.software.cant_save_state,android.software.companion_device_setup,android.software.controls,android.software.cts,android.software.device_admin,android.software.erofs,android.software.file_based_encryption,android.software.home_screen,android.software.incremental_delivery,android.software.input_methods,android.software.ipsec_tunnels,android.software.live_wallpaper,android.software.managed_users,android.software.midi,android.software.opengles.deqp.level,android.software.picture_in_picture,android.software.print,android.software.secure_lock_screen,android.software.securely_removes_users,android.software.telecom,android.software.verified_boot,android.software.voice_recognizers,android.software.vulkan.deqp.level,android.software.webview,com.google.android.apps.dialer.SUPPORTED,com.google.android.feature.EXCHANGE_6_2,com.google.android.feature.GOOGLE_BUILD,com.google.android.feature.GOOGLE_EXPERIENCE,com.google.android.feature.WELLBEING",
+  "GSF.version": "33",
+  "UserReadableName": "Android Emulator x86_64 (API 33)",
+  "Build.RADIO": "1.0.0.0",
+  "Client": "android-google",
+  "Locales": "af,af_ZA,am,am_ET,ar,ar_EG,ar_XB,as,az,be,bg,bg_BG,bn,bs,ca,ca_ES,cs,cs_CZ,da,da_DK,de,de_DE,el,el_GR,en,en_AU,en_CA,en_GB,en_IN,en_US,en_XA,es,es_ES,es_US,et,eu,fa,fa_IR,fi,fi_FI,fr,fr_CA,fr_FR,gl,gu,hi,hi_IN,hr,hr_HR,hu,hu_HU,hy,in,in_ID,is,it,it_IT,iw,iw_IL,ja,ja_JP,ka,kk,km,kn,ko,ko_KR,ky,lo,lt,lt_LT,lv,lv_LV,mk,ml,mn,mr,ms,ms_MY,my,nb,nb_NO,ne,nl,nl_NL,or,pa,pl,pl_PL,pt,pt_BR,pt_PT,ro,ro_RO,ru,ru_RU,si,sk,sk_SK,sl,sl_SI,sq,sr,sr_RS,sv,sv_SE,sw,sw_TZ,ta,te,th,th_TH,tl,tl_PH,tr,tr_TR,uk,uk_UA,ur,uz,vi,vi_VN,zh_CN,zh_HK,zh_TW,zu,zu_ZA",
+  "Screen.Density": "560",
+  "Platforms": "x86_64",
+  "Build.PRODUCT": "sdk_gphone64_x86_64",
+  "Navigation": "1",
+  "Keyboard": "2",
+  "Build.ID": "TE1A.240213.009",
+  "TimeZone": "UTC+1",
+  "Screen.Width": "1440",
+  "GL.Extensions": "GL_APPLE_texture_format_BGRA8888,GL_EXT_color_buffer_float,GL_EXT_color_buffer_half_float,GL_EXT_debug_marker,GL_EXT_robustness,GL_EXT_texture_format_BGRA8888,GL_KHR_texture_compression_astc_ldr,GL_OES_EGL_image,GL_OES_EGL_image_external,GL_OES_EGL_image_external_essl3,GL_OES_EGL_sync,GL_OES_compressed_ETC1_RGB8_texture,GL_OES_compressed_paletted_texture,GL_OES_depth24,GL_OES_depth32,GL_OES_depth_texture,GL_OES_element_index_uint,GL_OES_packed_depth_stencil,GL_OES_rgb8_rgba8,GL_OES_standard_derivatives,GL_OES_texture_float,GL_OES_texture_float_linear,GL_OES_texture_half_float,GL_OES_texture_half_float_linear,GL_OES_texture_npot,GL_OES_vertex_array_object,GL_OES_vertex_half_float",
+  "HasFiveWayNavigation": "false",
+  "TouchScreen": "3",
+  "GL.Version": "196608",
+  "Build.VERSION.RELEASE": "13",
+  "Build.BOOTLOADER": "unknown",
+  "Build.MANUFACTURER": "Google"
+};