whalibmob 5.12.17 → 5.13.1

package/.env.example

@@ -4,7 +4,10 @@
 #
 #     cp node_modules/whalibmob/.env.example .env
 #
-# The CLI loads `.env` from the current working directory automatically.
+# The CLI loads `.env` from the current working directory automatically — from
+# the directory the command runs in, not from where whalibmob is installed. Run
+# `wa` somewhere else and this file does not apply; export the variables in your
+# shell profile instead if you want them everywhere.
 # If you use the library programmatically, call `require('dotenv').config()`
 # yourself before creating a client.
 #
@@ -17,6 +20,19 @@
 # Values: ios | android
 # WA_OS=ios
 
+# Register as WhatsApp Business instead of the consumer app.
+# Values: 1 | true | yes | on  (anything else, or unset, means the consumer app)
+#
+# This has to be set before the code is requested: an account is created as
+# Business or as consumer, and the token, the User-Agent and the verified-name
+# certificate all have to keep saying which. A session already part-way through
+# registering keeps what it started as and says so.
+#
+# On Android the token material is read from com.whatsapp.w4b rather than
+# com.whatsapp, and is cached in its own file, so the two never overwrite each
+# other. On iOS the version comes from the Business App Store listing.
+# WA_BUSINESS=1
+
 # Named predefined device profile. Takes priority over the individual
 # WA_DEVICE_* variables below.
 #
@@ -51,15 +67,25 @@
 
 
 # ─── WhatsApp version ────────────────────────────────────────────────────────
-# Pin the WhatsApp client version. When set, the live version lookup is skipped
-# entirely, and this is what is announced on connect in place of the version
-# stored in the session. Leave unset to fetch the current version automatically.
-#
-# On Android this is normally not needed: the version comes from the APK the
-# token material was read from. On iOS it is looked up on the App Store, and a
-# lookup that fails leaves a built-in fallback version in the session — which
-# the server refuses at connect with a 405. That is what this is for.
-# WA_VERSION=2.24.10.75
+# LEAVE THIS UNSET. It is a temporary override, not a setting.
+#
+# When set, the live version lookup is skipped and this value is announced on
+# connect in place of the version the session was registered with — every
+# connect started from this directory, for every number, until it is removed.
+# The version WhatsApp accepts moves on every few weeks, so a value left here
+# eventually refuses every connect with `<failure reason="405">`, on sessions
+# that were working the day before. It is the single most common cause of that
+# error.
+#
+# On Android it is never needed: the version comes out of the APK the
+# registration token was signed over, which is the build the token actually
+# proves. Pinning something else here makes the two describe different builds.
+#
+# On iOS it is the escape hatch: the version is looked up on the App Store, and
+# a lookup that times out leaves a built-in fallback in the session that the
+# server may refuse. Pin a current version, connect, then remove the line —
+# uncomment this only when you have a 405 and a version to put in it.
+# WA_VERSION=
 
 # 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

package/README.md

@@ -121,6 +121,7 @@ npm install -g whalibmob
   - [Connecting Account](#connecting-account)
     - [Register a New Number](#register-a-new-number)
     - [Registering as Android](#registering-as-android)
+    - [Registering a WhatsApp Business account](#registering-a-whatsapp-business-account)
       - [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)
@@ -1644,6 +1645,47 @@ 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.
 
+### Registering a WhatsApp Business account
+
+Set `WA_BUSINESS`, or pass `--business`, and the whole registration switches to
+the Business build:
+
+```sh
+WA_OS=android WA_BUSINESS=1 wa registration --request-code 919634847671
+wa registration --register 919634847671 --code 123456
+wa connect 919634847671
+```
+
+Everything that names the app follows from that one variable:
+
+| | consumer | Business |
+|---|---|---|
+| announced platform | `ANDROID` / `IOS` | `ANDROID_BUSINESS` / `IOS_BUSINESS` |
+| User-Agent | `Android/…` · `iOS/…` | `SMBA/…` · `SMB iOS/…` |
+| Android token material | `com.whatsapp` | `com.whatsapp.w4b` |
+| iOS token constant | consumer | Business |
+| version lookup | consumer listing | Business listing |
+| `vname` field | not sent | a self-signed verified-name certificate |
+| Frida attestation port | 1119 | 1120 |
+
+The Android token material lives in its own file
+(`android-apk-material-business.json`), so the two builds never overwrite each
+other and `wa apk-material --download --business` can sit beside the consumer
+one.
+
+`vname` is a `VerifiedNameCertificate` the client signs itself, carrying an
+empty name, the issuer `smb:wa` and a random serial. The name is empty because
+nothing is verified yet — WhatsApp issues the real one after it reviews the
+business. What the server checks is that the signature over those details was
+made with the identity key the same request registers.
+
+> [!IMPORTANT]
+> **Decide before the code goes out.** An account is created as Business or as
+> consumer, and the token, the User-Agent and the certificate all have to keep
+> saying which. A session that is already part-way through registering keeps
+> what it started as and says so rather than flipping halfway; delete the
+> session file to start it over as the other one.
+
 #### Why an APK is involved at all
 
 The registration token is computed differently on each platform, and only iOS
@@ -4477,7 +4519,8 @@ These variables override individual fields on top of the selected profile:
 | Variable | Description |
 |---|---|
 | `WA_VERSION` | Pin the WhatsApp version (e.g. `2.24.13.80`). Skips the live store fetch, and is announced on connect **in place of the version stored in the session**. The CLI also reads it from a `.env` file in the working directory, so one left there is announced by every connect from that directory — which is how a working session starts being refused with [405](#when-the-server-answers-405-on-connect). Pin it deliberately, unset it when done. |
-| `WA_STATIC_TOKEN` | Override the static token used in registration token computation. iOS only — Android has no static token. |
+| `WA_STATIC_TOKEN` | Override the static token used in registration token computation. iOS only — Android has no static token. Overrides both the consumer and the Business constant. |
+| `WA_BUSINESS` | Register and connect as WhatsApp Business (`1`/`true`/`yes`/`on`). Decides the announced platform, the User-Agent, which APK the token material comes from, and the `vname` certificate. See [Registering a WhatsApp Business account](#registering-a-whatsapp-business-account). |
 
 ### When the server answers 405 on connect
 
@@ -4547,13 +4590,46 @@ each platform learns that differently:
 | iOS | looked up on the App Store | falls back to a version compiled into the library, which goes stale |
 | Android | read from the APK the registration token material came from | `wa apk-material --download` fetches the current one |
 
-So a genuinely stale session version is mostly an iOS story: a lookup that times
-out or is rate limited leaves an old fallback in the session, and nothing says so
-until the handshake is refused. On Android the version travels with the APK, and
-refreshing the material refreshes the version with it:
+**That version is written once, at registration, and nothing else ever touches
+it.** A number registered today announces today's version next year too, and one
+day the server stops accepting it — a 405 with nothing wrong with the account.
+Refreshing the APK material does not reach the sessions already on disk.
+
+`wa refresh-version` is the part that does:
 
 ```sh
-wa apk-material --download
+wa apk-material --download        # Android: pick up the current APK first
+wa refresh-version 5568936182750  # then write its version into the session
+```
+
+```
++5568936182750  android       2.24.10.75  →  2.26.30.5
+
+  1 session(s) updated
+  read from the APK the token material came from.
+  reconnect for it to be announced.
+```
+
+It touches `version` and nothing else — the keys, the device profile and the
+registration are left exactly as they were. `--all` does every session in the
+session directory, which is what belongs in a monthly cron for a bot that is
+meant to stay up:
+
+```sh
+wa apk-material --download && wa refresh-version --all
+```
+
+`--version 2.26.30.5` writes one you name instead of looking one up. And if
+`WA_VERSION` is set, the command says so — the override would mask whatever it
+writes.
+
+From Node, the same thing:
+
+```js
+const { refreshSessionVersion, currentVersionFor } = require('whalibmob')
+
+await refreshSessionVersion('/home/you/.waSession/5568936182750.json')
+await currentVersionFor({ os: 'android' })   // { version, source }
 ```
 
 #### If every Android session is refused, whatever the version
@@ -4569,14 +4645,17 @@ Sessions written before the fix repair themselves the next time they are loaded
 — the platform is derived from the profile's `os` rather than trusted from the
 file — so nothing has to be registered again.
 
-5.12.16 also brought the rest of the Android handshake in line with what a
-native Android client announces: no carrier (`mcc` and `mnc` are `000`), `en`
-and `US` as the locale, no `osBuildNumber`, the model rather than the model id
-as the device name, an uppercase `phoneId`, and `shortConnect`, `connectType`,
-`connectReason` and `connectAttemptCount` fixed at the values a real client
-sends on every connect — `connectType` had been sending `3`, which is not in the
-enum at all. iOS announces the real carrier and locale, which it has always been
-accepted with, and is unchanged.
+One other field in the same payload was wrong rather than merely unusual:
+`connectType` sent `3` on every reconnect, and the enum has no `3` — the legal
+values are `0` (cellular, unknown radio), `1` (wifi) and `100`–`112` for the
+named cellular radios. It now sends `1`.
+
+Nothing else in the payload changed. Other clients announce no carrier
+(`mcc`/`mnc` as `000`) and `en`/`US` regardless of the number; this library
+announces the carrier and locale the number actually belongs to, and a live
+session was tried against the server both ways — neither is refused. `000/000`
+is what a handset with no SIM reports, so a number with a carrier behind it
+saying so is the more ordinary thing to be.
 
 ### Finding out what a 405 objects to
 
@@ -4592,21 +4671,22 @@ node $(npm root -g)/whalibmob/tools/diagnose-405.js 5568936182750
 ```
 
 ```
-reference shape, as-is            ok — LOGIN ACCEPTED
-  + the real carrier (mcc/mnc)    ok — LOGIN ACCEPTED
-  + the real locale               405   {"reason":"405"}
+what this library sends           ok — LOGIN ACCEPTED
+  without the carrier (000/000)   ok — LOGIN ACCEPTED
+  without the locale (en/US)      ok — LOGIN ACCEPTED
 ```
 
 `405` means that row was refused, `401` means the client was accepted and only
-the credentials failed, `ok` means the login went through — so the first row
-that stops saying `ok` names the field the server objected to. Every row uses
-the session already on disk: nothing is registered, no code is requested, and
-the session is never written to. `--dry-run` prints the payload sizes without
-opening a socket.
-
-If *every* row is accepted while `wa connect` is refused, the payload is not the
-problem and the difference is in the environment the CLI reads and the tool does
-not — which is `WA_VERSION`, and the top of this section.
+the credentials failed, `ok` means the login went through. The first row is what
+a real connect puts on the wire, and each row after it changes exactly one
+field, so a row that behaves differently from the first names the field the
+server objected to. Every row uses the session already on disk: nothing is
+registered, no code is requested, and the session is never written to.
+`--dry-run` prints the payload sizes without opening a socket.
+
+**If the first row is accepted while `wa connect` is refused, the payload is not
+the problem.** The difference is then in what the CLI reads and this tool does
+not — `WA_VERSION`, from `.env`. Go back to the top of this section.
 
 ## License
 

package/cli.js

@@ -2358,6 +2358,7 @@ usage:
   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 refresh-version <phone>                  update the version a session announces
   wa version
 
 options:
@@ -2367,6 +2368,9 @@ options:
   --pair            connect by linking to an existing account (8-digit code)
   --method          sms | voice | wa_old | email  (default: sms)
   --email <address> email address (required when --method email)
+  --business        register/connect as WhatsApp Business (same as WA_BUSINESS=1)
+  --all             refresh-version: every session in the session directory
+  --version <x>     refresh-version: write this version instead of looking one up
 
 debug:
   an interactive session asks once whether to trace the protocol.
@@ -2448,6 +2452,12 @@ async function main() {
 
   _sessDir = flags.session || defaultSessionDir();
 
+  // `--business` is the flag form of WA_BUSINESS, mapped onto the environment
+  // before anything reads a device profile. The device config is env-driven, so
+  // this is the whole of it: the profile, the token material, the version
+  // lookup and the vname certificate all follow from that one variable.
+  if (flags.business) process.env.WA_BUSINESS = '1';
+
   if (!cmd) {
     out('whalibmob v' + VERSION + '  —  type /help for commands');
     openShell();
@@ -2465,6 +2475,67 @@ async function main() {
     return;
   }
 
+  // Bring a session's stored version up to date.
+  //
+  // A session announces the version it registered with, forever — nothing else
+  // writes that field, so a number registered today is still announcing today's
+  // version next year, and one day the server stops accepting it. Refreshing
+  // the APK material does not reach the sessions already on disk; this does.
+  // Run it after `wa apk-material --download`, or on a schedule.
+  if (cmd === 'refresh-version') {
+    const { refreshSessionVersion } = require('./lib/Registration');
+    const one = normalizePhone(sub || '');
+
+    if (!one && !flags.all) {
+      fail('usage: wa refresh-version <phone>   (or --all for every session)');
+      process.exit(1);
+    }
+
+    let files;
+    if (flags.all) {
+      try {
+        files = fs.readdirSync(_sessDir)
+          .filter(f => /^\d+\.json$/.test(f))
+          .map(f => path.join(_sessDir, f));
+      } catch (_) { files = []; }
+      if (!files.length) { fail('no sessions in ' + _sessDir); process.exit(1); }
+    } else {
+      files = [path.join(_sessDir, one + '.json')];
+    }
+
+    if (process.env.WA_VERSION) {
+      warn('WA_VERSION=' + process.env.WA_VERSION + ' is set — connecting will announce ' +
+           'that instead of what this command writes. Unset it for the refresh to take effect.');
+    }
+
+    let changed = 0, failed = 0;
+    const sources = new Set();
+    for (const file of files) {
+      try {
+        const r = await refreshSessionVersion(file, flags.version ? { version: flags.version } : null);
+        const who = '+' + r.phoneNumber + '  ' + r.os + (r.business ? '/business' : '');
+        if (r.changed) {
+          changed++;
+          sources.add(r.source);
+          out(who.padEnd(30) + r.before + '  →  ' + r.after);
+        } else {
+          out(who.padEnd(30) + r.after + '  (already current)');
+        }
+      } catch (e) {
+        failed++;
+        fail(path.basename(file) + ': ' + e.message);
+      }
+    }
+
+    out('');
+    out('  ' + changed + ' session(s) updated' + (failed ? ', ' + failed + ' failed' : ''));
+    if (changed) {
+      out('  read from ' + [...sources].join(', ') + '.');
+      out('  reconnect for it to be announced.');
+    }
+    process.exit(failed ? 1 : 0);
+  }
+
   // Read the Android registration token material out of a WhatsApp APK.
   //
   // Registering as Android signs its token with the APK's own signing
@@ -2479,9 +2550,15 @@ async function main() {
       out('       wa apk-material --download        fetch the APK from Google Play instead');
       process.exit(1);
     }
+    // The Business build gets its own file: it is signed with different
+    // certificates and carries a different classes.dex, so its token cannot be
+    // computed from the consumer material. `wa apk-material --download` and
+    // `--download --business` therefore do not overwrite each other.
     const outFile = flags.out ||
       process.env.WA_ANDROID_APK_MATERIAL ||
-      path.join(_sessDir, 'android-apk-material.json');
+      path.join(_sessDir, flags.business
+        ? 'android-apk-material-business.json'
+        : 'android-apk-material.json');
     try {
       const AndroidApk = require('./lib/AndroidApk');
       let material;

package/index.js

@@ -2,7 +2,7 @@
 
 const { WhalibmobClient, checkNumberStatus, fetchIosVersion, fetchWaVersion, assertRegistrationKeys } = require('./lib/Client');
 const { getDeviceConfig } = require('./lib/DeviceConfig');
-const { fetchAndroidVersion } = require('./lib/Registration');
+const { fetchAndroidVersion, currentVersionFor, refreshSessionVersion } = require('./lib/Registration');
 const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts, storeToJson, storeFromJson } = require('./lib/Store');
 const { checkIfRegistered, requestSmsCode, verifyCode } = require('./lib/Registration');
 const { SignalProtocol } = require('./lib/signal/SignalProtocol');
@@ -65,6 +65,10 @@ module.exports = {
   fetchWaVersion,
   fetchIosVersion,
   fetchAndroidVersion,
+  // What a device profile should be announcing now, and writing it into a
+  // session that registered long enough ago to have gone stale.
+  currentVersionFor,
+  refreshSessionVersion,
   // Device config — reads WA_OS / WA_DEVICE / WA_DEVICE_* from process.env
   getDeviceConfig,
   // Store helpers

package/lib/Attestation.js

@@ -23,7 +23,8 @@
 const crypto = require('crypto');
 const http   = require('http');
 
-const DEFAULT_PORT   = 1119;   // WhatsApp consumer; Business build listens on 1120
+const DEFAULT_PORT   = 1119;   // WhatsApp consumer
+const BUSINESS_PORT  = 1120;   // the Business build's own attestation server
 const REQUEST_TIMEMS = 15000;
 
 // ─── Empty (NONE) fallbacks ───────────────────────────────────────────────────
@@ -36,8 +37,12 @@ function fridaHost() {
   return process.env.WA_FRIDA_HOST || null;
 }
 
-function fridaPort() {
-  return parseInt(process.env.WA_FRIDA_PORT, 10) || DEFAULT_PORT;
+// The Business build's attestation server listens on its own port, because a
+// device can have both apps installed and each hooks its own process. An
+// explicit WA_FRIDA_PORT still wins over both.
+function fridaPort(device) {
+  return parseInt(process.env.WA_FRIDA_PORT, 10) ||
+    ((device && device.business) ? BUSINESS_PORT : DEFAULT_PORT);
 }
 
 function isEnabled() {
@@ -62,7 +67,7 @@ function toHex(buf) {
 // Returns the parsed JSON object on success, or null on any failure/timeout so
 // the caller can fall back to the empty NONE attestation.
 
-function fridaGet(pathname, query) {
+function fridaGet(pathname, query, device) {
   return new Promise((resolve) => {
     const host = fridaHost();
     if (!host) return resolve(null);
@@ -75,7 +80,7 @@ function fridaGet(pathname, query) {
       : '';
 
     const req = http.request(
-      { host, port: fridaPort(), path: pathname + qs, method: 'GET', timeout: REQUEST_TIMEMS },
+      { host, port: fridaPort(device), path: pathname + qs, method: 'GET', timeout: REQUEST_TIMEMS },
       (res) => {
         const chunks = [];
         res.on('data', d => chunks.push(d));
@@ -99,9 +104,9 @@ function fridaGet(pathname, query) {
 // leaves them empty — the server accepts a gpia-only attestation.
 //
 // nonceB64 is the URL-safe base64 request nonce (see attestationFieldsAndroid).
-async function androidIntegrity(nonceB64) {
+async function androidIntegrity(nonceB64, device) {
   if (!isEnabled()) return { ...EMPTY_ANDROID };
-  const res = await fridaGet('/integrity', { authKey: nonceB64 });
+  const res = await fridaGet('/integrity', { authKey: nonceB64 }, device);
   if (!res || !res.token) return { ...EMPTY_ANDROID };
   return { gpia: res.token, gg: '', gi: '', gp: '', ge: '', ga: '' };
 }
@@ -117,18 +122,18 @@ async function androidIntegrity(nonceB64) {
 //             server signs exactly those bytes.
 // The server returns { signature, certificate }: signature → the &H= body
 // suffix, certificate → the Authorization cert-chain header.
-async function androidAttestBody(encB64, authKeyB64) {
+async function androidAttestBody(encB64, authKeyB64, device) {
   if (!isEnabled()) return { ...EMPTY_BODY };
   const encParam = Buffer.from(encB64, 'utf8').toString('base64');
-  const res = await fridaGet('/cert', { authKey: authKeyB64, enc: encParam });
+  const res = await fridaGet('/cert', { authKey: authKeyB64, enc: encParam }, device);
   if (!res || !res.signature || !res.certificate) return { ...EMPTY_BODY };
   return { bodyAttestation: res.signature, authorizationHeader: res.certificate };
 }
 
 // ─── Android: device /info (apk hashes / signature / secret key) ──────────────
-async function androidInfo() {
+async function androidInfo(device) {
   if (!isEnabled()) return null;
-  return fridaGet('/info');
+  return fridaGet('/info', null, device);
 }
 
 // ─── iOS: App Attest (attestation + assertion + keyId) ────────────────────────
@@ -137,9 +142,9 @@ async function androidInfo() {
 // { attestation, assertion }; the keyId is generated per call on-device and
 // echoed by the server when available. clientDataHash is the base64 of the
 // Noise public key (the server SHA-256-hashes it internally).
-async function iosAppAttest(noisePubB64) {
+async function iosAppAttest(noisePubB64, device) {
   if (!isEnabled()) return { ...EMPTY_IOS };
-  const res = await fridaGet('/integrity', { authKey: noisePubB64 });
+  const res = await fridaGet('/integrity', { authKey: noisePubB64 }, device);
   if (!res || !res.attestation || !res.assertion) return { ...EMPTY_IOS };
   return {
     attestation: res.attestation,
@@ -171,7 +176,7 @@ async function attestationFields(device, nonceB64, opts) {
   const pushToken = orNull(opts.pushToken);
 
   if (device && device.os === 'android') {
-    const a = await androidIntegrity(nonceB64 || '');
+    const a = await androidIntegrity(nonceB64 || '', device);
     return [
       'gpia',       orNull(a.gpia),
       '_gg',        orNull(a.gg),
@@ -197,9 +202,9 @@ async function attestationFields(device, nonceB64, opts) {
 async function attestBody(encB64, device, keys) {
   keys = keys || {};
   if (device && device.os === 'android') {
-    return androidAttestBody(encB64, keys.noisePubB64 || '');
+    return androidAttestBody(encB64, keys.noisePubB64 || '', device);
   }
-  const data = await iosAppAttest(keys.noisePubB64 || '');
+  const data = await iosAppAttest(keys.noisePubB64 || '', device);
   if (!data.attestation || !data.assertion || !data.keyId) return { ...EMPTY_BODY };
   return {
     bodyAttestation:     '{"assertion":"' + data.assertion + '"}',

package/lib/DeviceConfig.js

@@ -38,19 +38,32 @@ for (const k of Object.keys(ANDROID_DEVICE_PROFILES)) _ANDROID_MAP[_normalise(k)
 //   WA_STATIC_TOKEN        override static registration token
 // ─────────────────────────────────────────────────────────────────────────────
 
+// WA_BUSINESS selects the WhatsApp Business build. It rides on top of the
+// device profile rather than replacing it — the same handsets exist for both
+// apps — and only changes which platform the profile announces, which package
+// the token material is read from, and which store the version comes from.
+function _wantsBusiness() {
+  const v = String(process.env.WA_BUSINESS || '').toLowerCase().trim();
+  return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+
 function getDeviceConfig() {
-  const osType = (process.env.WA_OS || 'ios').toLowerCase().trim();
+  const osType   = (process.env.WA_OS || 'ios').toLowerCase().trim();
+  const business = _wantsBusiness();
 
   if (osType === 'android') {
     const profileKey = _normalise(process.env.WA_DEVICE || 'samsungs24ultra');
     const found = _ANDROID_MAP[profileKey] || null;
     if (found) {
-      return Object.assign({}, found);
+      return Object.assign({}, found, business
+        ? { business: true, platform: PLATFORM.ANDROID_BUSINESS }
+        : { business: false });
     }
 
     return {
       os:              'android',
-      platform:        PLATFORM.ANDROID,
+      business,
+      platform:        business ? PLATFORM.ANDROID_BUSINESS : PLATFORM.ANDROID,
       model:           process.env.WA_DEVICE_MODEL        || 'Samsung Galaxy S24 Ultra',
       manufacturer:    process.env.WA_DEVICE_MANUFACTURER || 'Samsung',
       osVersion:       process.env.WA_DEVICE_OS_VERSION   || '14',
@@ -64,12 +77,15 @@ function getDeviceConfig() {
   const profileKey = _normalise(process.env.WA_DEVICE || 'iphone15pro');
   const found = _IOS_MAP[profileKey] || null;
   if (found) {
-    return Object.assign({}, found);
+    return Object.assign({}, found, business
+      ? { business: true, platform: PLATFORM.IOS_BUSINESS }
+      : { business: false });
   }
 
   return {
     os:              'ios',
-    platform:        PLATFORM.IOS,
+    business,
+    platform:        business ? PLATFORM.IOS_BUSINESS : PLATFORM.IOS,
     model:           process.env.WA_DEVICE_MODEL        || IOS_DEVICE.model,
     manufacturer:    process.env.WA_DEVICE_MANUFACTURER || IOS_DEVICE.manufacturer,
     osVersion:       process.env.WA_DEVICE_OS_VERSION   || IOS_DEVICE.osVersion,

package/lib/Registration.js

@@ -30,10 +30,18 @@ const { dbg: _whaDbg, warn: _whaWarn } = require('./logger');
 // which records them as observed on a live native Android registration. Its iOS
 // counterpart documents that the native iOS client omits all three, so the iOS
 // envelope stays exactly as it was.
+// The platform token in the User-Agent. The Business builds name themselves
+// differently — `SMBA` on Android, `SMB iOS` on iOS — and the registration
+// server reads the platform out of exactly this string.
+function _uaPlatformName(device) {
+  if (device.os === 'android') return device.business ? 'SMBA' : 'Android';
+  return device.business ? 'SMB iOS' : 'iOS';
+}
+
 function registrationHeaders(device, waVersion) {
   if (device.os === 'android') {
     return {
-      'User-Agent':     `WhatsApp/${waVersion} Android/${device.osVersion} Device/${device.manufacturer}-${device.modelId}`,
+      'User-Agent':     `WhatsApp/${waVersion} ${_uaPlatformName(device)}/${device.osVersion} Device/${device.manufacturer}-${device.modelId}`,
       'Content-Type':   'application/x-www-form-urlencoded',
       'Accept':         'text/json',
       'WaMsysRequest':  '1',
@@ -42,7 +50,7 @@ function registrationHeaders(device, waVersion) {
     };
   }
   return {
-    'User-Agent':   `WhatsApp/${waVersion} iOS/${device.osVersion} Device/${device.model}`,
+    'User-Agent':   `WhatsApp/${waVersion} ${_uaPlatformName(device)}/${device.osVersion} Device/${device.model}`,
     'Content-Type': 'application/x-www-form-urlencoded'
   };
 }
@@ -315,12 +323,17 @@ const {
   REGISTRATION_ENDPOINT,
   REGISTRATION_PUBLIC_KEY,
   IOS_STATIC_TOKEN,
+  IOS_BUSINESS_STATIC_TOKEN,
   IOS_VERSION_FALLBACK,
   ANDROID_VERSION_FALLBACK,
   IOS_USER_AGENT,
   IOS_DEVICE,
   SIGNAL_KEY_TYPE,
-  RELEASE_CHANNEL
+  RELEASE_CHANNEL,
+  WHATSAPP_PACKAGE,
+  WHATSAPP_BUSINESS_PACKAGE,
+  IOS_BUNDLE_ID,
+  IOS_BUSINESS_BUNDLE_ID
 } = require('./constants');
 
 // ---------- MD5 helpers ----------
@@ -457,14 +470,19 @@ function parsePhone(phoneNumber) {
 
 // ---------- WhatsApp version fetch (iOS from iTunes, Android from Play Store) ----------
 
-let _cachedIosVersion     = null;
-let _cachedAndroidVersion = null;
+// Cached per variant: the consumer and Business builds ship on their own
+// schedules, and announcing one's version as the other is a version the server
+// has no record of for that platform.
+const _cachedIosVersion     = {};
+const _cachedAndroidVersion = {};
 
-async function fetchIosVersion() {
-  if (_cachedIosVersion) return _cachedIosVersion;
+async function fetchIosVersion(business) {
+  const key = business ? 'business' : 'personal';
+  if (_cachedIosVersion[key]) return _cachedIosVersion[key];
+  const bundleId = business ? IOS_BUSINESS_BUNDLE_ID : IOS_BUNDLE_ID;
   return new Promise((resolve) => {
     const req = https.get(
-      'https://itunes.apple.com/lookup?bundleId=net.whatsapp.WhatsApp',
+      'https://itunes.apple.com/lookup?bundleId=' + bundleId,
       { headers: { 'User-Agent': IOS_USER_AGENT } },
       (res) => {
         const chunks = [];
@@ -474,7 +492,7 @@ async function fetchIosVersion() {
             const json = JSON.parse(Buffer.concat(chunks).toString('utf8'));
             let ver = (json.results && json.results[0] && json.results[0].version) || IOS_VERSION_FALLBACK;
             if (!ver.startsWith('2.')) ver = '2.' + ver;
-            _cachedIosVersion = ver;
+            _cachedIosVersion[key] = ver;
             resolve(ver);
           } catch (_) {
             resolve(IOS_VERSION_FALLBACK);
@@ -490,12 +508,14 @@ async function fetchIosVersion() {
 // Fetch latest WhatsApp Android version from Google Play Store.
 // Parses the 4-part "2.x.x.x" version string embedded in the page JSON data.
 // Falls back to ANDROID_VERSION_FALLBACK on any error.
-async function fetchAndroidVersion() {
-  if (_cachedAndroidVersion) return _cachedAndroidVersion;
+async function fetchAndroidVersion(business) {
+  const key = business ? 'business' : 'personal';
+  if (_cachedAndroidVersion[key]) return _cachedAndroidVersion[key];
+  const packageName = business ? WHATSAPP_BUSINESS_PACKAGE : WHATSAPP_PACKAGE;
   try {
     const axios = require('axios');
     const resp = await axios.get(
-      'https://play.google.com/store/apps/details?id=com.whatsapp&hl=en&gl=us',
+      'https://play.google.com/store/apps/details?id=' + packageName + '&hl=en&gl=us',
       {
         headers: {
           'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
@@ -523,14 +543,14 @@ async function fetchAndroidVersion() {
     // In Play Store JSON the current stable version appears first, before beta/history entries.
     const primary = html.match(/"(2\.\d+\.\d+\.\d+)"/);
     if (primary) {
-      _cachedAndroidVersion = primary[1];
+      _cachedAndroidVersion[key] = primary[1];
       return primary[1];
     }
 
     // Secondary: unquoted version adjacent to "WhatsApp" text (catches alternate HTML structures).
     const secondary = html.match(/WhatsApp[^<"]{0,200}?(2\.\d+\.\d+\.\d+)/);
     if (secondary) {
-      _cachedAndroidVersion = secondary[1];
+      _cachedAndroidVersion[key] = secondary[1];
       return secondary[1];
     }
 
@@ -541,7 +561,7 @@ async function fetchAndroidVersion() {
     if (all && all.length) {
       const newest = all.sort(compareVersions).pop();
       _whaDbg('[DBG] ANDROID_VERSION scraped from an unrecognised page layout: ' + newest);
-      _cachedAndroidVersion = newest;
+      _cachedAndroidVersion[key] = newest;
       return newest;
     }
 
@@ -577,14 +597,87 @@ function compareVersions(a, b) {
 // 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.
+/**
+ * The version a device profile should be announcing right now, and where it
+ * came from.
+ *
+ * Deliberately ignores WA_VERSION: this answers "what is current" so a stored
+ * version can be brought up to date, and an override in the environment is the
+ * opposite of that — it is what masks the session's own value at connect.
+ *
+ * @param {object} device  the profile, for os and business
+ * @returns {Promise<{version: string, source: string}>}
+ */
+async function currentVersionFor(device) {
+  device = device || getDeviceConfig();
+  const business = !!device.business;
+  if (device.os === 'android') {
+    const material = tryLoadAndroidMaterial(device);
+    if (material && material.apkVersion) {
+      return { version: material.apkVersion, source: 'the APK the token material came from' };
+    }
+    return { version: await fetchAndroidVersion(business), source: 'the Play Store listing' };
+  }
+  return { version: await fetchIosVersion(business), source: 'the App Store listing' };
+}
+
+/**
+ * Bring a session's stored version up to date.
+ *
+ * A session records the version it registered with and announces that forever
+ * after; nothing else ever writes the field. Months later the server stops
+ * accepting it and the connect is refused with a 405 that has nothing to do
+ * with the account. Refreshing the APK material does not help on its own — it
+ * updates the material, not the sessions already on disk. This is the part that
+ * was missing.
+ *
+ * Touches `version` and nothing else. The device profile, the keys and the
+ * registration are left exactly as they were.
+ *
+ * @param {string} sessionFile   path to <number>.json
+ * @param {object} [opts]        { version } to set one explicitly
+ * @returns {Promise<{phoneNumber, before, after, changed, source}>}
+ */
+async function refreshSessionVersion(sessionFile, opts) {
+  opts = opts || {};
+  const { loadStore, saveStore } = require('./Store');
+
+  const store = loadStore(sessionFile);
+  if (!store) throw new Error('no session at ' + sessionFile);
+
+  const device = store.device || getDeviceConfig();
+  const before = store.version;
+
+  const resolved = opts.version
+    ? { version: String(opts.version), source: 'the value you passed' }
+    : await currentVersionFor(device);
+
+  const changed = resolved.version !== before;
+  if (changed) {
+    store.version = resolved.version;
+    saveStore(store, sessionFile);
+  }
+
+  return {
+    phoneNumber: store.phoneNumber,
+    before,
+    after:       resolved.version,
+    changed,
+    source:      resolved.source,
+    os:          device.os,
+    business:    !!device.business
+  };
+}
+
 async function fetchWaVersion(device) {
   if (process.env.WA_VERSION) return process.env.WA_VERSION;
+  const business = !!(device && device.business);
   if (device && device.os === 'android') {
-    const material = tryLoadAndroidMaterial();
+    const material = tryLoadAndroidMaterial(device);
     if (material && material.apkVersion) return material.apkVersion;
-    return fetchAndroidVersion();
+    return fetchAndroidVersion(business);
   }
-  return fetchIosVersion();
+  return fetchIosVersion(business);
 }
 
 // ---------- Token computation ----------
@@ -606,17 +699,24 @@ async function fetchWaVersion(device) {
 
 // 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');
+// One file per package. The two builds are signed with different certificates
+// and carry a different classes.dex, so a token computed from the consumer APK
+// is not the token the Business endpoint expects — and the consumer file keeps
+// its original name, so nothing that already exists has to move.
+function androidMaterialPath(device) {
+  if (process.env.WA_ANDROID_APK_MATERIAL) return process.env.WA_ANDROID_APK_MATERIAL;
+  const name = (device && device.business)
+    ? 'android-apk-material-business.json'
+    : 'android-apk-material.json';
+  return path.join(os.homedir(), '.waSession', name);
 }
 
-let _androidMaterial = null;
+const _androidMaterial = {};
 
 // 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 tryLoadAndroidMaterial(device) {
+  try { return loadAndroidMaterial(device); } catch (_) { return null; }
 }
 
 /**
@@ -643,12 +743,25 @@ function deviceForRegistration(store, opts) {
   const settled = !!(store && (store.registered || store.codePending));
   if (!settled || !stored) return env;
 
+  const say = (opts && opts.onProgress) || (m => _whaDbg('[DBG] REG ' + m));
+
   if (stored.os !== env.os) {
-    const say = (opts && opts.onProgress) || (m => _whaDbg('[DBG] REG ' + m));
     say('note: this session was started as ' + stored.os + ', so it stays ' + stored.os +
         ' — WA_OS=' + env.os + ' does not apply to a number that is already part-way ' +
         'through registering. Delete the session file to start it over as ' + env.os + '.');
   }
+
+  // The same rule for the variant: an account is created as Business or as
+  // consumer, and the token, the User-Agent and the vname certificate all have
+  // to keep saying which. Flipping it halfway leaves a registration that no
+  // build can finish.
+  if (!!stored.business !== !!env.business) {
+    say('note: this session was started as ' + (stored.business ? 'Business' : 'consumer') +
+        ', so it stays that — WA_BUSINESS=' + (env.business ? '1' : '0') +
+        ' does not apply to a number that is already part-way through registering. ' +
+        'Delete the session file to start it over.');
+  }
+
   return stored;
 }
 
@@ -672,8 +785,11 @@ async function ensureAndroidMaterial(opts, device) {
   device = device || getDeviceConfig();
   if (device.os !== 'android') return null;
 
+  const variant    = device.business ? 'business' : 'personal';
+  const packageName = device.business ? WHATSAPP_BUSINESS_PACKAGE : WHATSAPP_PACKAGE;
+
   try {
-    return loadAndroidMaterial();
+    return loadAndroidMaterial(device);
   } catch (err) {
     if (err.code !== 'NO_APK_MATERIAL') throw err;
     if (process.env.WA_NO_APK_DOWNLOAD === '1') throw err;
@@ -683,10 +799,10 @@ async function ensureAndroidMaterial(opts, device) {
   const AndroidApk = require('./AndroidApk');
   const PlayStore  = require('./PlayStore');
 
-  say('no Android token material yet — fetching the WhatsApp APK from Google Play');
+  say('no Android token material yet — fetching ' + packageName + ' from Google Play');
   let apk;
   try {
-    apk = await PlayStore.downloadApk({ onProgress: m => say('  ' + m) });
+    apk = await PlayStore.downloadApk({ packageName, 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' +
@@ -697,27 +813,28 @@ async function ensureAndroidMaterial(opts, device) {
   if (!material.apkVersion)     material.apkVersion     = apk.versionName;
   if (!material.apkVersionCode) material.apkVersionCode = apk.versionCode;
 
-  const file = androidMaterialPath();
+  const file = androidMaterialPath(device);
   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();
+  _androidMaterial[variant] = null;
+  return loadAndroidMaterial(device);
 }
 
-function loadAndroidMaterial() {
-  if (_androidMaterial) return _androidMaterial;
-  const file = androidMaterialPath();
+function loadAndroidMaterial(device) {
+  const variant = (device && device.business) ? 'business' : 'personal';
+  if (_androidMaterial[variant]) return _androidMaterial[variant];
+  const file = androidMaterialPath(device);
   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' +
+      '  wa apk-material --download' + (variant === 'business' ? ' --business' : '') + '\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.');
@@ -745,20 +862,23 @@ function loadAndroidMaterial() {
       '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' +
+      '  pm path ' + (variant === 'business' ? WHATSAPP_BUSINESS_PACKAGE : WHATSAPP_PACKAGE) + '\n' +
       'then re-run wa apk-material with it. Set WA_ALLOW_FOREIGN_APK=1 to send it anyway.');
   }
 
-  _androidMaterial = material;
-  return _androidMaterial;
+  _androidMaterial[variant] = material;
+  return material;
 }
 
 function computeToken(waVersion, national, device) {
   device = device || getDeviceConfig();
   if (device.os === 'android') {
-    return AndroidApk.computeToken(loadAndroidMaterial(), national);
+    return AndroidApk.computeToken(loadAndroidMaterial(device), national);
   }
-  const staticToken    = process.env.WA_STATIC_TOKEN || IOS_STATIC_TOKEN;
+  // The Business build signs with its own constant. WA_STATIC_TOKEN still
+  // overrides either, for anyone who has a newer one than this ships with.
+  const staticToken    = process.env.WA_STATIC_TOKEN ||
+    (device.business ? IOS_BUSINESS_STATIC_TOKEN : IOS_STATIC_TOKEN);
   const versionHashHex = md5Bytes(waVersion).toString('hex');
   return md5Hex(staticToken + versionHashHex + national);
 }
@@ -891,6 +1011,74 @@ function toBase64Url(buf) {
   return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_');
 }
 
+// ---------- vname: the Business verified-name certificate ----------
+//
+// A Business registration carries one extra form field, `vname`, and a consumer
+// one carries none. It is a VerifiedNameCertificate the client signs itself:
+//
+//   Details      { 1 serial (uint64), 2 issuer "smb:wa", 4 verifiedName "" }
+//   Certificate  { 1 details (the encoded Details), 2 signature }
+//
+// The name is empty because there is nothing verified yet — WhatsApp issues the
+// real one later, after the business is reviewed. What the server checks here is
+// that the signature over the details is made with the identity key the same
+// request registers, which ties the certificate to this account and no other.
+//
+// Written by hand rather than through the protobuf models: these two messages
+// exist nowhere else in the library, and the encoder here is the same field/
+// wire-type pair used everywhere else in proto.js.
+
+const VNAME_ISSUER_SMALL_BUSINESS = 'smb:wa';
+
+function _pbVarint(n) {
+  const out = [];
+  let v = BigInt(n);
+  while (v > 127n) { out.push(Number((v & 0x7fn) | 0x80n)); v >>= 7n; }
+  out.push(Number(v));
+  return Buffer.from(out);
+}
+
+function _pbLenField(fieldNum, buf) {
+  return Buffer.concat([_pbVarint((fieldNum << 3) | 2), _pbVarint(buf.length), buf]);
+}
+
+function _pbVarintField(fieldNum, value) {
+  return Buffer.concat([_pbVarint((fieldNum << 3) | 0), _pbVarint(value)]);
+}
+
+/**
+ * The `vname` form value for a Business registration, or null for a consumer one.
+ *
+ * @param {object} store   the session, for the identity key that signs it
+ * @param {object} device  the active device profile
+ */
+function buildVerifiedNameCertificate(store, device) {
+  if (!device || !device.business) return null;
+
+  // A positive 63-bit serial: Java takes the absolute value of a random long,
+  // and Math.abs(Long.MIN_VALUE) is still negative there, so the top bit is
+  // simply never set here instead.
+  const serialBytes = crypto.randomBytes(8);
+  serialBytes[0] &= 0x7f;
+  const serial = serialBytes.readBigUInt64BE(0);
+
+  const details = Buffer.concat([
+    _pbVarintField(1, serial),
+    _pbLenField(2, Buffer.from(VNAME_ISSUER_SMALL_BUSINESS, 'utf8')),
+    _pbLenField(4, Buffer.alloc(0))            // verifiedName: empty, not absent
+  ]);
+
+  // Signed with the identity key, over the encoded details exactly as they go
+  // on the wire — the same XEdDSA signature the signed pre-key uses.
+  const signature = Buffer.from(
+    curveJs.sign(store.identityKeyPair.private, details));
+
+  return toBase64Url(Buffer.concat([
+    _pbLenField(1, details),
+    _pbLenField(2, signature)
+  ]));
+}
+
 async function buildPayload(store, waVersion, useToken, extraPairs) {
   const { cc, national } = parsePhone(store.phoneNumber);
   const meta   = getCountryMeta(cc);
@@ -919,6 +1107,9 @@ async function buildPayload(store, waVersion, useToken, extraPairs) {
     'lg',                meta.lg,
     'lc',                meta.lc,
     'authkey',           toBase64Url(stripKeyPrefix(store.noiseKeyPair.public)),
+    // Business only; buildForm drops a null, so a consumer registration sends
+    // the same body it always has.
+    'vname',             buildVerifiedNameCertificate(store, device),
     'e_regid',           toBase64Url(intToBytes(store.registrationId, 4)),
     'e_keytype',         toBase64Url(Buffer.from([SIGNAL_KEY_TYPE])),
     'e_ident',           toBase64Url(stripKeyPrefix(store.identityKeyPair.public)),
@@ -1622,13 +1813,13 @@ async function verifyCode(store, code, opts) {
   throw new Error(`Verification failed: ${reason || JSON.stringify(result)}`);
 }
 
-module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, parsePhone, getCountryMeta, assertRegistrationKeys, parseSocksProxy, socksProxyUrl };
+module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchWaVersion, currentVersionFor, refreshSessionVersion, parsePhone, getCountryMeta, assertRegistrationKeys, parseSocksProxy, socksProxyUrl };
 
 // 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, deviceForRegistration };
+module.exports._token = { computeToken, androidMaterialPath, registrationHeaders, ensureAndroidMaterial, deviceForRegistration, buildVerifiedNameCertificate, buildPayload };
 
 // Challenge / two-factor internals, exposed for tests. Not part of the public API.
 module.exports._verify = {

package/lib/Store.js

@@ -8,7 +8,7 @@ const crypto = require('crypto');
 const curveJs = require('curve25519-js');
 const { v4: uuidv4 } = require('uuid');
 const { IOS_DEVICE, IOS_VERSION_FALLBACK, ANDROID_VERSION_FALLBACK,
-        platformForOs } = require('./constants');
+        platformForOs, isBusinessPlatform } = require('./constants');
 const { getDeviceConfig } = require('./DeviceConfig');
 
 // ─────────────────────────────────────────────────────────
@@ -111,10 +111,20 @@ function createNewStore(phoneNumber) {
 // deliberately, so it decides, and a stale number is repaired the moment the
 // session is read. Nothing has to be registered again over it.
 function normaliseDevice(device) {
-  const merged   = Object.assign({}, IOS_DEVICE, device || null);
-  const expected = platformForOs(merged.os);
+  const merged = Object.assign({}, IOS_DEVICE, device || null);
+
+  // Which variant this session is. The flag is what a session written since
+  // Business support landed carries; the stored platform number is what one
+  // written by hand, or by an older build, can still say. Either is enough, so
+  // that repairing the platform below can never turn a Business session into a
+  // consumer one.
+  const business = merged.business === true || isBusinessPlatform(merged.platform);
+  merged.business = business;
+
+  const expected = platformForOs(merged.os, business);
   if (merged.platform !== expected) {
     _whaDbg('[DBG] DEVICE_PLATFORM_FIXED os=' + merged.os +
+      (business ? ' business' : '') +
       ' ' + merged.platform + ' → ' + expected);
     merged.platform = expected;
   }

package/lib/constants.js

@@ -70,17 +70,40 @@ const IOS_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X)
 //
 // Anything that needs a platform number takes it from here.
 const PLATFORM = {
-  ANDROID: 0,
-  IOS:     1,
-  WEB:     14
+  ANDROID:          0,
+  IOS:              1,
+  ANDROID_BUSINESS: 10,
+  IOS_BUSINESS:     12,
+  WEB:              14
 };
 
 // The platform an `os` string announces itself as. Unknown values fall back to
 // iOS, which is what a session with no device profile has always been.
-function platformForOs(os) {
-  return String(os).toLowerCase() === 'android' ? PLATFORM.ANDROID : PLATFORM.IOS;
+//
+// The Business builds are their own platforms rather than a flag on top of the
+// consumer ones: a WhatsApp Business account is registered, tokenised and
+// announced as ANDROID_BUSINESS or IOS_BUSINESS from the first request, and
+// mixing the two halves produces an account that neither app can open.
+function platformForOs(os, business) {
+  const android = String(os).toLowerCase() === 'android';
+  if (business) return android ? PLATFORM.ANDROID_BUSINESS : PLATFORM.IOS_BUSINESS;
+  return android ? PLATFORM.ANDROID : PLATFORM.IOS;
+}
+
+// Whether a stored platform number is one of the Business ones, so a session
+// written before this existed keeps answering the same way.
+function isBusinessPlatform(platform) {
+  return platform === PLATFORM.ANDROID_BUSINESS || platform === PLATFORM.IOS_BUSINESS;
 }
 
+// The Play Store packages and the App Store bundle ids, per variant. The
+// Android token material is read out of whichever APK the account is being
+// registered as, and the two builds sign with different material entirely.
+const WHATSAPP_PACKAGE          = 'com.whatsapp';
+const WHATSAPP_BUSINESS_PACKAGE = 'com.whatsapp.w4b';
+const IOS_BUNDLE_ID             = 'net.whatsapp.WhatsApp';
+const IOS_BUSINESS_BUNDLE_ID    = 'net.whatsapp.WhatsAppSMB';
+
 // A note on the `deviceModelType` numbers in the profiles below: nothing reads
 // them. The proto's deviceModelType (field 16) is a string and is filled from
 // `modelId`; the proto's deviceType (field 15) is the DeviceType enum, which is
@@ -273,6 +296,11 @@ module.exports = {
   IOS_USER_AGENT,
   PLATFORM,
   platformForOs,
+  isBusinessPlatform,
+  WHATSAPP_PACKAGE,
+  WHATSAPP_BUSINESS_PACKAGE,
+  IOS_BUNDLE_ID,
+  IOS_BUSINESS_BUNDLE_ID,
   IOS_DEVICE,
   IOS_DEVICE_PROFILES,
   ANDROID_DEVICE_PROFILES,

package/lib/noise.js

@@ -375,7 +375,7 @@ class NoiseSocket extends EventEmitter {
       // ClientPayload userAgent is never sent with the telltale '000'/'000' values.
       const _phoneMeta  = getCountryMeta(parsePhone(this.store.phoneNumber).cc);
       const _device     = this.store.device || {};
-      const _isAndroid  = String(_device.os).toLowerCase() === 'android';
+      const _reconnect  = (this.store.connectAttemptCount || 0) > 0;
       const _version    = process.env.WA_VERSION || this.store.version;
 
       this._announcedVersion    = _version;
@@ -384,21 +384,20 @@ class NoiseSocket extends EventEmitter {
       _whaDbg('[DBG] ANNOUNCING version=' + _version +
         (this._versionFromEnv ? ' (from WA_VERSION, session holds ' +
           this.store.version + ')' : ' (from the session)') +
-        ' platform=' + platformForOs(_device.os));
+        ' platform=' + platformForOs(_device.os, _device.business));
 
       const payload = encodeClientPayload({
         username:           BigInt(this.store.phoneNumber),
         passive:            false,
         pushName:           this.store.registered ? (this.store.name || null) : null,
-        // The next four are constants in the reference client: it announces
-        // shortConnect, WIFI_UNKNOWN, USER_ACTIVATED and attempt 0 on every
-        // connect, retries included. ConnectType is a closed set — 0
-        // CELLULAR_UNKNOWN, 1 WIFI_UNKNOWN, 100-112 for the named cellular
-        // radios — and a reconnect used to send 3, which is not in it.
-        shortConnect:       true,
+        shortConnect:       _reconnect,
+        // ConnectType is a closed set — 0 CELLULAR_UNKNOWN, 1 WIFI_UNKNOWN,
+        // and 100-112 for the named cellular radios. There is no 3, which is
+        // what every reconnect used to send. This is the only one of these
+        // four that was wrong rather than merely different.
         connectType:        CONNECT_TYPE_WIFI,
         connectReason:      CONNECT_REASON_USER_ACTIVATED,
-        connectAttemptCount: 0,
+        connectAttemptCount: (this.store.connectAttemptCount || 0),
         device:             0,
         oc:                 false,
         userAgent: {
@@ -410,7 +409,7 @@ class NoiseSocket extends EventEmitter {
           // corrected cannot keep announcing BlackBerry. ANDROID is 0, so the
           // old `|| 1` fallback would also have quietly turned every Android
           // session into an iOS one.
-          platform:        platformForOs(_device.os),
+          platform:        platformForOs(_device.os, _device.business),
           // The version the session was registered with, unless WA_VERSION says
           // otherwise. Without that override there is no way out of a 405: the
           // version lives in the session file, the server refuses it, and the
@@ -423,25 +422,23 @@ class NoiseSocket extends EventEmitter {
           // file still holds a version the server would have accepted. Both are
           // remembered here so the failure can say which one went out.
           version:         _version,
-          // Android announces no carrier and no locale of its own: the
-          // reference client sends 000/000 and en/US on this platform and is
-          // accepted, and this is the half that was being refused. iOS is
-          // accepted as it is and keeps sending the real values.
-          mcc:             _isAndroid ? '000' : _phoneMeta.mcc,
-          mnc:             _isAndroid ? '000' : _phoneMeta.mnc,
+          // The real carrier and locale, derived from the number, on both
+          // platforms. Other clients send 000/000 and en/US here, and the
+          // server accepts a session either way — this was tried against it
+          // both ways and neither is refused. 000/000 is what a handset with
+          // no SIM reports, so a number with a carrier behind it saying so is
+          // the more ordinary thing to be, which is why this library picked
+          // the real values in the first place.
+          mcc:             _phoneMeta.mcc,
+          mnc:             _phoneMeta.mnc,
           osVersion:       _device.osVersion,
           manufacturer:    _device.manufacturer,
           device:          _device.model,
-          // Not sent on Android by the reference client, which describes the
-          // handset with manufacturer and model alone. iOS does send it.
-          osBuildNumber:   _isAndroid ? null : _device.osBuildNumber,
-          // Uppercase on both platforms, even though the Android registration
-          // sends the same id lowercase — that asymmetry is the reference
-          // client's, not an oversight.
+          osBuildNumber:   _device.osBuildNumber,
           phoneId:         this.store.fdid.toUpperCase(),
           releaseChannel:  0,
-          localeLanguage:  _isAndroid ? 'en' : _phoneMeta.lg,
-          localeCountry:   _isAndroid ? 'US' : _phoneMeta.lc,
+          localeLanguage:  _phoneMeta.lg,
+          localeCountry:   _phoneMeta.lc,
           // DeviceType enum (field 15): PHONE. Every profile shipped here is a
           // phone — the numeric `deviceModelType` on the profiles is unrelated
           // to this and is read by nothing.

package/package.json

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

package/tools/diagnose-405.js

@@ -15,8 +15,10 @@
 //   401  the client was accepted and only the credentials were rejected
 //   ok   the login succeeded
 //
-// Read it by comparing rows: the first row that stops saying 405 names the
-// field that was the problem.
+// Read it by comparing rows: the first row is what a connect actually sends, so
+// if it is accepted the payload is not the problem — check WA_VERSION, which the
+// CLI reads from .env and this tool does not. If it is refused, the row that
+// behaves differently names the field responsible.
 
 const path = require('path');
 const os   = require('os');
@@ -57,23 +59,24 @@ const meta   = getCountryMeta(parsePhone(store.phoneNumber).cc);
 const device = store.device || {};
 const isAndroid = String(device.os).toLowerCase() === 'android';
 
-// What the reference client announces on Android, and the knobs that differ
-// between it and what this library used to send.
+// With no overrides this is exactly what a connect puts on the wire. Each
+// override changes one field, so a row that behaves differently from the first
+// one names the field responsible.
 function payloadFor(over) {
   over = over || {};
   const ua = {
     platform:        over.platform !== undefined ? over.platform : platformForOs(device.os),
     version:         over.version  || store.version,
-    mcc:             over.realCarrier ? meta.mcc : '000',
-    mnc:             over.realCarrier ? meta.mnc : '000',
+    mcc:             over.noCarrier ? '000' : meta.mcc,
+    mnc:             over.noCarrier ? '000' : meta.mnc,
     osVersion:       device.osVersion,
     manufacturer:    device.manufacturer,
     device:          over.useModelId ? device.modelId : device.model,
-    osBuildNumber:   over.withBuild ? device.osBuildNumber : null,
+    osBuildNumber:   over.noBuild ? null : device.osBuildNumber,
     phoneId:         over.lowerPhoneId ? store.fdid.toLowerCase() : store.fdid.toUpperCase(),
     releaseChannel:  0,
-    localeLanguage:  over.realLocale ? meta.lg : 'en',
-    localeCountry:   over.realLocale ? meta.lc : 'US',
+    localeLanguage:  over.noLocale ? 'en' : meta.lg,
+    localeCountry:   over.noLocale ? 'US' : meta.lc,
     deviceType:      0,
     deviceModelType: device.modelId
   };
@@ -81,7 +84,7 @@ function payloadFor(over) {
     username:            BigInt(store.phoneNumber),
     passive:             false,
     pushName:            store.registered ? (store.name || null) : null,
-    shortConnect:        true,
+    shortConnect:        false,
     connectType:         1,
     connectReason:       1,
     connectAttemptCount: 0,
@@ -113,15 +116,15 @@ function attempt(over) {
 
 const sleep = ms => new Promise(r => setTimeout(r, ms));
 
-// One variable at a time, starting from the reference client's exact shape.
+// One variable at a time, starting from what this library actually sends.
 const ROWS = [
-  ['reference client, as-is',        {}],
-  ['  + the real carrier (mcc/mnc)', { realCarrier: true }],
-  ['  + the real locale',            { realLocale: true }],
-  ['  + osBuildNumber',              { withBuild: true }],
-  ['  + model id as the device',     { useModelId: true }],
-  ['  + lowercase phoneId',          { lowerPhoneId: true }],
-  ['everything the old code sent',   { realCarrier: true, realLocale: true, withBuild: true }],
+  ['what this library sends',        {}],
+  ['  without the carrier (000/000)',{ noCarrier: true }],
+  ['  without the locale (en/US)',   { noLocale: true }],
+  ['  without osBuildNumber',        { noBuild: true }],
+  ['  model id as the device',       { useModelId: true }],
+  ['  lowercase phoneId',            { lowerPhoneId: true }],
+  ['  none of the above',            { noCarrier: true, noLocale: true, noBuild: true }],
   ['announced as iOS',               { platform: PLATFORM.IOS }]
 ];