whalibmob 5.12.11 → 5.12.14

package/.env.example

@@ -66,14 +66,27 @@
 
 
 # ─── Android registration token material ─────────────────────────────────────
-# Registering with WA_OS=android needs material read out of a WhatsApp APK once:
+# Registering with WA_OS=android needs material read out of a WhatsApp APK. The
+# first registration fetches the APK from Google Play and does this on its own —
+# nothing to run first. To do it by hand, from a Play download or an APK you
+# already have:
 #
+#     wa apk-material --download
 #     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
 
+# Never fetch the APK automatically. Registration then fails with instructions
+# instead of pulling a hundred megabytes unasked.
+# WA_NO_APK_DOWNLOAD=1
+
+# Register with material from an APK that is not signed by WhatsApp. Refused by
+# default, because a re-signed APK yields a token that belongs to nobody and
+# spends code requests against your number for nothing.
+# WA_ALLOW_FOREIGN_APK=1
+
 
 # ─── Proxy ───────────────────────────────────────────────────────────────────
 # Route registration traffic through a SOCKS proxy. Requires the `socks`

package/README.md

@@ -121,6 +121,9 @@ npm install -g whalibmob
   - [Connecting Account](#connecting-account)
     - [Register a New Number](#register-a-new-number)
     - [Registering as Android](#registering-as-android)
+      - [Why an APK is involved at all](#why-an-apk-is-involved-at-all)
+      - [Fetching the APK on its own](#fetching-the-apk-on-its-own)
+      - [Reading it out of an APK you already have](#reading-it-out-of-an-apk-you-already-have)
     - [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)
@@ -274,10 +277,6 @@ 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
@@ -291,6 +290,16 @@ wa registration --request-code 919634847671 --method voice
 wa registration --request-code 919634847671 --method wa_old
 ```
 
+**Registering as Android** is the same command with the platform named. Nothing
+else to prepare — see [what it does behind that one command](#registering-as-android):
+
+```sh
+WA_OS=android WA_DEVICE=samsung-s24-ultra wa registration --request-code 919634847671 --debug
+```
+
+Set `WA_OS=android` in a `.env` file instead and the plain command is enough.
+`--debug` prints every request and reply, which is worth having the first time.
+
 The CLI sends the code request, prints the result, and then **stays open** in the interactive shell. You will see:
 
 ```
@@ -1551,6 +1560,34 @@ Both are optional and both keep working when omitted — you get an error naming
 
 ### Registering as Android
 
+**There is nothing to do first.** Name the platform and register:
+
+```sh
+WA_OS=android WA_DEVICE=samsung-s24-ultra wa registration --request-code 919634847671 --debug
+```
+
+The first Android registration finds no token material, fetches the WhatsApp APK
+from Google Play, reads what it needs out of it, checks that WhatsApp really
+signed it, and carries on to the code request — one command, no APK to find:
+
+```
+no Android token material yet — fetching the WhatsApp APK from Google Play
+    version 2.26.30.3 (code 263000302)
+    downloading base.apk and 1 density split (of 24 the server offered): config.xxxhdpi
+    token material written to /home/you/.waSession/android-apk-material.json
+requesting sms code for +919634847671...
+  status  sent
+```
+
+It happens once. Every later registration reads the file. `WA_NO_APK_DOWNLOAD=1`
+turns the fetch off if you would rather it never pulled a hundred megabytes
+unasked, and `wa apk-material` below does the same job by hand.
+
+The rest of this section is what happens behind that one command, and how to
+drive each part yourself.
+
+#### Why an APK is involved at all
+
 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:
@@ -1568,7 +1605,34 @@ the iOS-shaped token as Android is answered with `{"reason":"bad_token"}`, and n
 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:
+#### Fetching the APK on its own
+
+This runs by itself on a registration that finds no material. To do it separately
+— to refresh after a WhatsApp release, or just to see what it picks up:
+
+```sh
+wa apk-material --download
+```
+
+It is the route Cobalt takes: an anonymous Play Store token from the Aurora OSS
+dispenser, then Google's own `/fdfe` catalogue and delivery endpoints, then the
+signed CDN URLs. **No Google account of yours is involved.** Only the density
+splits are downloaded — the token's key comes from `about_logo.png`, which lives
+in one of those, and the architecture and language splits would be a hundred
+megabytes nothing here reads.
+
+Two caveats. The dispenser is a free third-party service: when it is down or rate
+limiting, this fails and an APK from a phone still works. And downloading from
+Play this way is against Play's terms of service, which is your call to make.
+
+Play serves the splits that suit the device profile it is asked as, not the full
+set a bundle holds, so the density this yields can differ from the one in a
+complete bundle — and a different density is a different key. The `about_logo`
+line in the output names which one was used.
+
+#### Reading it out of an APK you already have
+
+Pull one off any phone or emulator that has WhatsApp installed:
 
 ```sh
 adb shell pm path com.whatsapp
@@ -1593,10 +1657,21 @@ reading base.apk...
   package               com.whatsapp
   version               2.26.25.80  (code 260908001)
   certificates          1
+  signed by             C=US, ST=California, L=Santa Clara, O=WhatsApp Inc., …
+  sha256                AD:AD:64:31:29:8F:64:2B:…
   classes.dex md5       5c71f02aaad331e16e436bfa83ea3c5b
   written to            /home/you/.waSession/android-apk-material.json
 ```
 
+**Watch the `signed by` line.** The token is an HMAC over the signing
+certificates, so it is only the token the server expects when those certificates
+are WhatsApp's own. Mirrors re-sign the APKs they host, commonly with the AOSP
+test key whose private half ships in the Android sources — a re-signed APK yields
+a token that is well-formed and belongs to nobody. Anything other than WhatsApp
+in that subject is called out here as a warning, and registration refuses to
+start on it rather than spending code requests against your number on something
+that cannot succeed. `WA_ALLOW_FOREIGN_APK=1` sends it anyway.
+
 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.
@@ -1608,8 +1683,10 @@ 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.
+**Refresh it on a new WhatsApp release.** `classes.dex` changes every release and
+its MD5 is signed into the token, so material from an older build stops matching
+the version being announced. `wa apk-material --download` re-reads the current
+one; deleting the file and registering again does the same thing on its own.
 
 Programmatically:
 

package/cli.js

@@ -252,9 +252,26 @@ function enableWireTrace() {
     };
     req.on('response', (res) => {
       trace(`\n${C.http}${stamp()} ◀── HTTP ${res.statusCode} from ${host}${C.off}`);
-      let body = '';
-      res.on('data', d => { if (body.length < 8192) body += d.toString('utf8'); });
-      res.on('end', () => { if (body) trace(`  ${C.dim}${body}${C.off}`); });
+      // Registration answers in JSON, so the body was printed as text. An APK
+      // download answers in tens of megabytes of binary, and printing that as
+      // text emptied a terminal full of control characters. Keep a bounded head
+      // of it, decide from those bytes whether it is text at all, and say what
+      // it was rather than showing it when it is not.
+      const head = [];
+      let seen = 0, total = 0;
+      res.on('data', (d) => {
+        total += d.length;
+        if (seen < 4096) { head.push(d); seen += d.length; }
+      });
+      res.on('end', () => {
+        if (!total) return;
+        const buf = Buffer.concat(head).slice(0, 4096);
+        if (isPrintable(buf)) {
+          trace(`  ${C.dim}${buf.toString('utf8')}${total > buf.length ? ' …' : ''}${C.off}`);
+        } else {
+          trace(`  ${C.dim}[${total} bytes, binary]${C.off}`);
+        }
+      });
     });
     return req;
   };
@@ -2068,7 +2085,7 @@ async function handleLine(line) {
           }
           const methodLabel = method === 'email' ? ('email → ' + emailAddr) : method;
           out('requesting ' + methodLabel + ' code for +' + ph + '...');
-          const codeOpts = method === 'email' ? { email: emailAddr } : {};
+          const codeOpts = Object.assign(method === 'email' ? { email: emailAddr } : {}, { onProgress: out });
           const r = await requestSmsCode(store, method, codeOpts);
           store.codePending = true;
           saveStore(store, sessFile);
@@ -2083,7 +2100,7 @@ async function handleLine(line) {
           const file  = path.join(_sessDir, `${ph}.json`);
           const store = loadStore(file) || initAuthCreds(ph);
           out('verifying...');
-          const r = await verifyCode(store, code, registrationPrompts());
+          const r = await verifyCode(store, code, Object.assign(registrationPrompts(), { onProgress: out }));
           if (r && (r.status === 'ok' || r.status === 'sent' || r.status === 'verified')) {
             if (!fs.existsSync(_sessDir)) fs.mkdirSync(_sessDir, { recursive: true });
             const finalStore = r.store || store;
@@ -2329,6 +2346,7 @@ usage:
   wa registration --register <phone> --code <code>
   wa registration --check <phone>
   wa apk-material <base.apk> [split.apk ...]  read the Android token material
+  wa apk-material --download                  fetch that APK from Google Play
   wa version
 
 options:
@@ -2445,8 +2463,9 @@ async function main() {
   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) {
+    if (!apks.length && !flags.download) {
       fail('usage: wa apk-material <base.apk> [split.apk ...]');
+      out('       wa apk-material --download        fetch the APK from Google Play instead');
       process.exit(1);
     }
     const outFile = flags.out ||
@@ -2454,12 +2473,26 @@ async function main() {
       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) }))
-      );
+      let material;
+      if (flags.download) {
+        const PlayStore = require('./lib/PlayStore');
+        out('fetching ' + (flags.business ? 'com.whatsapp.w4b' : 'com.whatsapp') + ' from Google Play...');
+        const apk = await PlayStore.downloadApk({
+          packageName: flags.business ? 'com.whatsapp.w4b' : 'com.whatsapp',
+          onProgress:  (m) => out('  ' + m)
+        });
+        material = AndroidApk.extractMaterial(apk.base, apk.splits);
+        // The catalogue's version is the authority when the manifest has none.
+        if (!material.apkVersion)     material.apkVersion     = apk.versionName;
+        if (!material.apkVersionCode) material.apkVersionCode = apk.versionCode;
+      } else {
+        const [basePath, ...splitPaths] = apks;
+        out('reading ' + basePath + '...');
+        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));
@@ -2467,10 +2500,24 @@ async function main() {
       kv('version', material.apkVersion
         ? material.apkVersion + (material.apkVersionCode ? '  (code ' + material.apkVersionCode + ')' : '')
         : '(not in the manifest — pass --version <x.y.z.w>)');
+      if (material.aboutLogoFrom) kv('about_logo', material.aboutLogoFrom);
       kv('certificates', String(material.certificates.length));
+      const signer = AndroidApk.describeCertificate(material.certificates[0]);
+      if (signer) {
+        kv('signed by', signer.subject);
+        kv('sha256', signer.fingerprint256);
+      }
       kv('classes.dex md5', material.classesDexMd5.toString('hex'));
       kv('written to', outFile);
       out('');
+      if (signer && !AndroidApk.looksLikeWhatsAppCertificate(signer)) {
+        warn('this APK is not signed by WhatsApp — the subject above is somebody else.');
+        out('  Mirrors re-sign the APKs they host, and re-signing replaces the certificate');
+        out('  the token is built from. The token will come out well-formed and belong to');
+        out('  nobody, which the server answers with bad_token. Use the APK installed on a');
+        out('  phone instead: pm path com.whatsapp');
+        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');
@@ -2541,7 +2588,7 @@ async function main() {
       const methodLabel = method === 'email' ? ('email → ' + emailAddr) : method;
       out('requesting ' + methodLabel + ' code for +' + ph + '...');
       try {
-        const codeOpts = method === 'email' ? { email: emailAddr } : {};
+        const codeOpts = Object.assign(method === 'email' ? { email: emailAddr } : {}, { onProgress: out });
         const r = await requestSmsCode(store, method, codeOpts);
         store.codePending = true;
         saveStore(store, sessFile);
@@ -2567,7 +2614,7 @@ async function main() {
       const store = loadStore(file) || initAuthCreds(ph);
       out('verifying code for +' + ph + '...');
       try {
-        const r = await verifyCode(store, code, registrationPrompts());
+        const r = await verifyCode(store, code, Object.assign(registrationPrompts(), { onProgress: out }));
         if (r && (r.status === 'ok' || r.status === 'sent' || r.status === 'verified')) {
           if (!fs.existsSync(_sessDir)) fs.mkdirSync(_sessDir, { recursive: true });
           const finalStore = r.store || store;

package/lib/AndroidApk.js

@@ -289,21 +289,31 @@ function _isDensitySplit(fileName) {
 function extractMaterial(base, splits) {
   const entries = readZipDirectory(base);
 
+  // Which about_logo.png, when there is more than one.
+  //
+  // A released bundle ships the drawable in every density split — seven of them
+  // — and its bytes are the PBKDF2 password, so picking a different density
+  // yields a different key and a token the server will not accept. Searching
+  // split by split makes the answer depend on the order the splits happen to be
+  // passed in, which for a shell glob is alphabetical and for Cobalt is whatever
+  // its download map iterated: same APK, different token.
+  //
+  // So the path decides, not the split. ABOUT_LOGO_PATHS is ordered — hdpi
+  // first, the xxhdpi fallback last — and every candidate is searched for the
+  // first path before any is searched for the second. The base APK keeps
+  // priority within each path, since a release that still carries the drawable
+  // itself is not a bundle at all.
   let aboutLogo = null;
+  let aboutLogoFrom = null;
   for (const p of ABOUT_LOGO_PATHS) {
     aboutLogo = readZipEntry(base, entries, p);
-    if (aboutLogo) break;
-  }
-  if (!aboutLogo) {
+    if (aboutLogo) { aboutLogoFrom = p; break; }
     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;
+      aboutLogo = readZipEntry(split.data, readZipDirectory(split.data), p);
+      if (aboutLogo) { aboutLogoFrom = split.name + ':' + p; break; }
     }
+    if (aboutLogo) break;
   }
   if (!aboutLogo) {
     throw new Error('about_logo.png is in neither the base APK nor any density split — ' +
@@ -333,6 +343,9 @@ function extractMaterial(base, splits) {
     secretKey:     deriveSecretKey(packageName, aboutLogo),
     classesDexMd5: crypto.createHash('md5').update(classesDex).digest(),
     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.
+    aboutLogoFrom,
     // 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,
@@ -366,6 +379,40 @@ function computeToken(material, national) {
   return encodeURIComponent(mac.digest().toString('base64'));
 }
 
+// Who signed the APK, so it can be told apart from a repack.
+//
+// The token is an HMAC over the signing certificates, so it is only the token
+// the server expects when those certificates are WhatsApp's own. An APK a mirror
+// re-signed carries the mirror's certificate instead and produces a token that
+// is perfectly well-formed and belongs to nobody — which comes back as
+// bad_token, indistinguishable from having no material at all. Reading the
+// subject out is what turns that into something visible before it is sent.
+//
+// Returns null on a runtime without X509Certificate (Node < 15.6) rather than
+// making the extraction depend on it.
+function describeCertificate(der) {
+  if (typeof crypto.X509Certificate !== 'function') return null;
+  try {
+    const cert = new crypto.X509Certificate(der);
+    return {
+      subject:       cert.subject.replace(/\n/g, ', '),
+      issuer:        cert.issuer.replace(/\n/g, ', '),
+      fingerprint256: cert.fingerprint256,
+      validFrom:     cert.validFrom,
+      validTo:       cert.validTo
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+// WhatsApp's own signing certificate names the company in its subject. A repack
+// cannot keep that — re-signing replaces the certificate outright — so a subject
+// without it is the one thing worth saying out loud.
+function looksLikeWhatsAppCertificate(description) {
+  return !!(description && /WhatsApp/i.test(description.subject));
+}
+
 // ─── Storage ──────────────────────────────────────────────────────────────────
 //
 // Only the derived pieces are kept, the way Cobalt caches them — the APK itself
@@ -399,6 +446,8 @@ function materialFromJson(json) {
 module.exports = {
   extractMaterial,
   parseManifest,
+  describeCertificate,
+  looksLikeWhatsAppCertificate,
   deriveSecretKey,
   computeToken,
   materialToJson,

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

@@ -137,7 +137,7 @@ function socksProxyUrl() {
   return process.env.TOR_PROXY || process.env.SOCKS_PROXY || '';
 }
 
-async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader) {
+async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, device) {
   const proxy = parseSocksProxy(proxyUrl);
   const dHost = 'v.whatsapp.net';
   const dPort = 443;
@@ -164,7 +164,7 @@ async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader) {
     tlsSocket.once('error', rej);
   });
 
-  const headers  = registrationHeaders(getDeviceConfig(), waVersion);
+  const headers  = registrationHeaders(device || getDeviceConfig(), waVersion);
   const reqLines = [
     `POST /v2${path} HTTP/1.1`,
     `Host: ${dHost}`,
@@ -575,6 +575,62 @@ 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, device) {
+  opts = opts || {};
+  device = 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();
@@ -582,18 +638,46 @@ function loadAndroidMaterial() {
   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' +
+    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' +
-      '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.');
+      '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;
   }
-  _androidMaterial = AndroidApk.materialFromJson(JSON.parse(raw));
+  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();
+function computeToken(waVersion, national, device) {
+  device = device || getDeviceConfig();
   if (device.os === 'android') {
     return AndroidApk.computeToken(loadAndroidMaterial(), national);
   }
@@ -733,8 +817,8 @@ function toBase64Url(buf) {
 async function buildPayload(store, waVersion, useToken, extraPairs) {
   const { cc, national } = parsePhone(store.phoneNumber);
   const meta   = getCountryMeta(cc);
-  const token  = useToken ? computeToken(waVersion, national) : null;
   const device = store.device || getDeviceConfig();
+  const token  = useToken ? computeToken(waVersion, national, device) : null;
   // Android formats fdid lowercase, iOS uppercase (matches the native clients).
   const fdid   = device.os === 'android'
     ? store.fdid.toLowerCase()
@@ -790,14 +874,14 @@ function encryptPayload(plaintext) {
 
 // ---------- HTTP ----------
 
-function httpPost(path, body, waVersion, authHeader) {
+function httpPost(path, body, waVersion, authHeader, device) {
   const proxy = socksProxyUrl();
-  if (proxy) return httpPostViaSocks(path, body, waVersion, proxy, authHeader);
+  if (proxy) return httpPostViaSocks(path, body, waVersion, proxy, authHeader, device);
 
   return new Promise((resolve, reject) => {
     const bodyBuf = Buffer.from(body, 'utf8');
     const headers = Object.assign(
-      registrationHeaders(getDeviceConfig(), waVersion),
+      registrationHeaders(device || getDeviceConfig(), waVersion),
       { 'Content-Length': bodyBuf.length }
     );
     // Attestation cert-chain / App Attest header (Android cert chain, iOS
@@ -859,7 +943,7 @@ async function sendEncrypted(path, plaintext, store, waVersion) {
 
   _whaDbg('[DBG] REG → ' + path + ' (' + body.length + ' bytes' +
     (bodyAtt.bodyAttestation ? ', attested' : '') + ')');
-  const result = await httpPost(path, body, waVersion, bodyAtt.authorizationHeader);
+  const result = await httpPost(path, body, waVersion, bodyAtt.authorizationHeader, device);
   _whaDbg('[DBG] REG ← ' + path + ' ' +
     (result && result.status ? result.status : JSON.stringify(result).slice(0, 120)) +
     (result && result.reason ? ' reason=' + result.reason : ''));
@@ -1109,7 +1193,7 @@ async function handle2FA(store, waVersion, opts) {
 // ---------- Public API ----------
 
 async function checkIfRegistered(store) {
-  const waVersion = await fetchWaVersion(getDeviceConfig());
+  const waVersion = await fetchWaVersion(store.device || getDeviceConfig());
   return sendRequest('/exist', store, waVersion, false, null);
 }
 
@@ -1247,7 +1331,14 @@ async function assertRegistrationKeys(store, waVersion) {
 async function requestSmsCode(store, method, opts) {
   method = method || 'sms';
   opts   = opts   || {};
-  const _device   = getDeviceConfig();
+  // Before the version is read, since on Android the version comes out of the
+  // APK this fetches.
+  // What a session registered as is settled when it is created, so it is the
+  // store that decides — not whatever WA_OS the shell happens to carry now. A
+  // confirmation run from a shell without the variables would otherwise sign an
+  // Android registration with an iOS token.
+  const _device   = store.device || getDeviceConfig();
+  await ensureAndroidMaterial(opts, _device);
   const waVersion = await fetchWaVersion(_device);
   store.version = waVersion;
   store.device  = _device;
@@ -1366,7 +1457,14 @@ async function requestSmsCode(store, method, opts) {
 
 async function verifyCode(store, code, opts) {
   opts = opts || {};
-  const _device   = getDeviceConfig();
+  // Normally already there from the code request, but a confirmation can be run
+  // from a fresh shell that never made one.
+  // What a session registered as is settled when it is created, so it is the
+  // store that decides — not whatever WA_OS the shell happens to carry now. A
+  // confirmation run from a shell without the variables would otherwise sign an
+  // Android registration with an iOS token.
+  const _device   = store.device || getDeviceConfig();
+  await ensureAndroidMaterial(opts, _device);
   const waVersion = await fetchWaVersion(_device);
   store.version = waVersion;
   store.device  = _device;
@@ -1461,7 +1559,7 @@ module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyC
 module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody };
 
 // Token computation, exposed for tests. Not part of the public API.
-module.exports._token = { computeToken, androidMaterialPath, registrationHeaders };
+module.exports._token = { computeToken, androidMaterialPath, registrationHeaders, ensureAndroidMaterial };
 
 // Challenge / two-factor internals, exposed for tests. Not part of the public API.
 module.exports._verify = {

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"
+};

package/package.json

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