whalibmob 5.33.26 → 5.33.29

package/lib/Registration.js

@@ -3,6 +3,7 @@
 const crypto = require('crypto');
 const https  = require('https');
 const tls    = require('tls');
+const zlib   = require('zlib');
 const fs     = require('fs');
 const os     = require('os');
 const path   = require('path');
@@ -40,13 +41,18 @@ function _uaPlatformName(device) {
 
 function registrationHeaders(device, waVersion) {
   if (device.os === 'android') {
+    // Header set and order mirror the native client's registration POST: no
+    // Accept, Connection kept alive, gzip advertised (the response is gunzipped
+    // on both the direct and SOCKS paths). request_token is an UPPERCASE UUID —
+    // the native client never mints a lowercase one.
     return {
-      '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',
+      'User-Agent':      `WhatsApp/${waVersion} ${_uaPlatformName(device)}/${device.osVersion} Device/${device.manufacturer}-${device.modelId}`,
+      'WaMsysRequest':   '1',
       // A fresh one per request, the way the native client mints it.
-      'request_token':  uuidv4()
+      'request_token':   uuidv4().toUpperCase(),
+      'Content-Type':    'application/x-www-form-urlencoded',
+      'Connection':      'Keep-Alive',
+      'Accept-Encoding': 'gzip'
     };
   }
   return {
@@ -66,7 +72,7 @@ const {
   parseSocksProxy, socksProxyUrl, socksConnect, proxyAgent
 } = require('./socks');
 
-async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, device) {
+async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, device, query) {
   const dHost = 'v.whatsapp.net';
   const dPort = 443;
 
@@ -88,23 +94,27 @@ async function httpPostViaSocks(path, body, waVersion, proxyUrl, authHeader, dev
   });
 
   const headers  = registrationHeaders(device || getDeviceConfig(), waVersion);
+  // The native client submits the parameters twice: once in the clear as the
+  // URL query, once encrypted inside ENC. The query string here is the exact
+  // plaintext that was encrypted, byte for byte.
+  const target   = query ? `/v2${path}?${query}` : `/v2${path}`;
   const reqLines = [
-    `POST /v2${path} HTTP/1.1`,
+    `POST ${target} HTTP/1.1`,
     `Host: ${dHost}`,
     ...Object.keys(headers).map(k => `${k}: ${headers[k]}`),
     `Content-Length: ${Buffer.byteLength(body)}`
   ];
   if (authHeader) reqLines.push(`Authorization: ${authHeader}`);
-  // Asked for, but not relied on: the server answers and then keeps the
-  // connection open anyway. The response is finished by its own length, not by
-  // the socket closing.
-  reqLines.push(`Connection: close`, '', body);
+  // Connection: Keep-Alive rides in from registrationHeaders, matching the
+  // native client; the response is still delimited by its own length and the
+  // socket is destroyed once it is read.
+  reqLines.push('', body);
   const req = reqLines.join('\r\n');
 
   tlsSocket.write(req);
 
-  const { status, body: bodyBuf } = await readHttpResponse(tlsSocket, path);
-  const bodyStr = bodyBuf.toString('utf8');
+  const { status, headers: resHeaders, body: bodyBuf } = await readHttpResponse(tlsSocket, path);
+  const bodyStr = decodeBody(bodyBuf, resHeaders).toString('utf8');
 
   if (status !== 200) throw new Error(`HTTP ${status} ${path}: ${bodyStr}`);
   try { return JSON.parse(bodyStr); } catch (_) { return { raw: bodyStr }; }
@@ -172,6 +182,17 @@ function readHttpResponse(socket, label, timeoutMs) {
   });
 }
 
+// The registration POST advertises `Accept-Encoding: gzip`, so the server may
+// answer gzip-compressed. Decode by the response's own content-encoding; fall
+// back to the raw bytes if the header lies or the stream will not inflate, so a
+// plain reply still parses. `headers` is the raw header block (any case).
+function decodeBody(bodyBuf, headers) {
+  if (/^content-encoding:[ \t]*gzip/im.test(headers || '')) {
+    try { return zlib.gunzipSync(bodyBuf); } catch (_) { /* fall through */ }
+  }
+  return bodyBuf;
+}
+
 /**
  * Parse what has arrived so far.
  *
@@ -1221,6 +1242,61 @@ function toUrlHex(buf) {
 // IMPORTANT: do NOT use URLSearchParams here — it would double-encode the
 //            percent-hex sequences in the 'id' field (%AA → %25AA).
 
+// The native client inserts registration fields into a LinkedHashMap in a
+// fixed order; the wire sequence is that insertion order, not a sort. These are
+// the live orders captured from WhatsApp Android (WA_REVERSE_2026): 50 fields
+// for /v2/code, 49 for /v2/register. gpia/token/vname that this build omits
+// simply drop out — their slots collapse.
+const CODE_PARAM_ORDER = [
+  'method', 'backup_token', '_gs', 'sim_mnc', 'id', 'mnc', '_gg',
+  'network_radio_type', 'lg', 'rc', 'pid', '_ge', 'cellular_strength', 'gpia',
+  'hasinrc', 'aid', 'mcc', '_gp', 'hasav', 'device_ram', 'db', 'sim_type',
+  'prefer_sms_over_flash', 'access_session_id', 'sim_mcc', 'roaming_type',
+  'mistyped', 'airplane_mode_type', 'e_ident', 'e_skey_sig', 'entrypoint',
+  'token', 'in', 'expid', 'simnum', 'cc', 'education_screen_displayed',
+  'e_skey_val', 'authkey', 'e_keytype', 'e_regid', 'client_metrics', '_gi',
+  'e_skey_id', 'feo2_query_status', 'reason', 'fdid', 'recaptcha', '_ga', 'lc'
+];
+
+const REGISTER_PARAM_ORDER = [
+  'code', 'backup_token', 'sim_mnc', '_gs', 'id', 'device_ram', 'db', '_gg',
+  'sim_operator_name', 'passkey_login_status', 'lg', 'rc', 'network_radio_type',
+  'pid', '_ge', 'cellular_strength', 'gpia', 'hasinrc', 'aid',
+  'network_operator_name', 'mcc', '_gp', 'mnc', 'entered', 'access_session_id',
+  'sim_mcc', 'roaming_type', 'mistyped', 'airplane_mode_type', 'has_play_store',
+  'sim_type', 'e_ident', 'e_skey_sig', 'entrypoint', 'in', 'expid', 'simnum',
+  'cc', 'e_skey_val', 'authkey', 'e_keytype', 'e_regid', '_gi', 'client_metrics',
+  'e_skey_id', 'fdid', 'recaptcha', '_ga', 'lc'
+];
+
+// Reorder a flat [k, v, k, v, …] list to the native insertion order for the
+// endpoint. Keys outside the reference order (push_token and any build-specific
+// extras) keep their relative order and trail the known fields, so nothing is
+// dropped. Only /v2/code and /v2/register have a reference order; every other
+// endpoint (client_log, exist, …) and every non-Android device passes through
+// untouched.
+function reorderRegistrationPairs(pairs, path, device) {
+  const order = path === '/code' ? CODE_PARAM_ORDER
+              : path === '/register' ? REGISTER_PARAM_ORDER
+              : null;
+  if (!order || !device || device.os !== 'android') return pairs;
+
+  const orderSet = new Set(order);
+  const seen     = new Map();
+  const extras   = [];
+  for (let i = 0; i < pairs.length; i += 2) {
+    const k = pairs[i];
+    if (seen.has(k)) continue;
+    seen.set(k, pairs[i + 1]);
+    if (!orderSet.has(k)) extras.push(k);
+  }
+
+  const out = [];
+  for (const k of order)  if (seen.has(k)) out.push(k, seen.get(k));
+  for (const k of extras) out.push(k, seen.get(k));
+  return out;
+}
+
 function buildForm(pairs, extraPairs) {
   const parts = [];
   for (let i = 0; i < pairs.length; i += 2) {
@@ -1517,6 +1593,16 @@ function toBase64Url(buf) {
   return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_');
 }
 
+// The native client encodes the Signal-key and expid wire parameters with
+// Base64.encodeToString(bytes, 11) = URL_SAFE | NO_WRAP | NO_PADDING: authkey
+// (43 chars), e_ident/e_skey_val (43), e_skey_sig (86), e_regid (6), e_keytype,
+// e_skey_id (4), expid (22) — never a trailing '='. The padded form still
+// decodes server-side, but the bare '=' is a wire tell no real device emits.
+// The ENC envelope and the vname certificate keep their own encoder above.
+function toBase64UrlNoPad(buf) {
+  return toBase64Url(buf).replace(/=+$/, '');
+}
+
 // ---------- vname: the Business verified-name certificate ----------
 //
 // A Business registration carries one extra form field, `vname`, and a consumer
@@ -1585,7 +1671,7 @@ function buildVerifiedNameCertificate(store, device) {
   ]));
 }
 
-async function buildPayload(store, waVersion, useToken, extraPairs) {
+async function buildPayload(store, waVersion, useToken, extraPairs, path) {
   const { cc, national } = parsePhone(store.phoneNumber);
   const meta   = getCountryMeta(cc, store);
   const device = store.device || getDeviceConfig();
@@ -1630,29 +1716,34 @@ async function buildPayload(store, waVersion, useToken, extraPairs) {
     ga: store._gaToken
   });
 
-  return buildForm([
+  const basePairs = [
     'cc',                cc,
     'in',                national,
     'rc',                String(RELEASE_CHANNEL),
     'lg',                meta.lg,
     'lc',                meta.lc,
-    'authkey',           toBase64Url(stripKeyPrefix(store.noiseKeyPair.public)),
+    'authkey',           toBase64UrlNoPad(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)),
-    'e_skey_id',         toBase64Url(intToBytes(store.signedPreKey.id, 3)),
-    'e_skey_val',        toBase64Url(stripKeyPrefix(store.signedPreKey.public)),
-    'e_skey_sig',        toBase64Url(store.signedPreKey.signature),
+    'e_regid',           toBase64UrlNoPad(intToBytes(store.registrationId, 4)),
+    'e_keytype',         toBase64UrlNoPad(Buffer.from([SIGNAL_KEY_TYPE])),
+    'e_ident',           toBase64UrlNoPad(stripKeyPrefix(store.identityKeyPair.public)),
+    'e_skey_id',         toBase64UrlNoPad(intToBytes(store.signedPreKey.id, 3)),
+    'e_skey_val',        toBase64UrlNoPad(stripKeyPrefix(store.signedPreKey.public)),
+    'e_skey_sig',        toBase64UrlNoPad(store.signedPreKey.signature),
     'fdid',              fdid,
-    'expid',             toBase64Url(store.deviceId),
+    'expid',             toBase64UrlNoPad(store.deviceId),
     'id',                toUrlHex(store.identityId),
     'access_session_id', getAccessSessionId(store),
     'token',             token,
     ...attestFields
-  ], extraPairs);
+  ];
+  const allPairs = extraPairs ? basePairs.concat(extraPairs) : basePairs;
+  // Emit the fields in the native client's fixed insertion order for /code and
+  // /register. The order is part of the wire fingerprint and, with the query
+  // now mirrored into the URL, is visible to the server in the clear.
+  return buildForm(reorderRegistrationPairs(allPairs, path, device));
 }
 
 // ---------- Encryption (AES-256-GCM, ephemeral X25519) ----------
@@ -1672,9 +1763,9 @@ function encryptPayload(plaintext) {
 
 // ---------- HTTP ----------
 
-function httpPost(path, body, waVersion, authHeader, device) {
+function httpPost(path, body, waVersion, authHeader, device, query) {
   const proxy = socksProxyUrl();
-  if (proxy) return httpPostViaSocks(path, body, waVersion, proxy, authHeader, device);
+  if (proxy) return httpPostViaSocks(path, body, waVersion, proxy, authHeader, device, query);
 
   return new Promise((resolve, reject) => {
     const bodyBuf = Buffer.from(body, 'utf8');
@@ -1685,10 +1776,13 @@ function httpPost(path, body, waVersion, authHeader, device) {
     // Attestation cert-chain / App Attest header (Android cert chain, iOS
     // <attestation>|<keyId>). Only present when body attestation is available.
     if (authHeader) headers['Authorization'] = authHeader;
+    // The native client submits the parameters twice: once in the clear as the
+    // URL query, once encrypted inside ENC. The query is the exact ENC
+    // plaintext, byte for byte.
     const opts = {
       hostname: 'v.whatsapp.net',
       port: 443,
-      path: '/v2' + path,
+      path: query ? '/v2' + path + '?' + query : '/v2' + path,
       method: 'POST',
       timeout: 20000,
       headers
@@ -1697,7 +1791,12 @@ function httpPost(path, body, waVersion, authHeader, device) {
       const chunks = [];
       res.on('data', d => chunks.push(d));
       res.on('end', () => {
-        const text = Buffer.concat(chunks).toString('utf8');
+        const encoding = String(res.headers['content-encoding'] || '');
+        let buf = Buffer.concat(chunks);
+        if (/gzip/i.test(encoding)) {
+          try { buf = zlib.gunzipSync(buf); } catch (_) { /* keep raw */ }
+        }
+        const text = buf.toString('utf8');
         if (res.statusCode !== 200) {
           return reject(new Error(`HTTP ${res.statusCode} ${path}: ${text}`));
         }
@@ -1713,7 +1812,7 @@ function httpPost(path, body, waVersion, authHeader, device) {
 }
 
 async function sendRequest(path, store, waVersion, useToken, extraPairs) {
-  const plaintext = await buildPayload(store, waVersion, useToken, extraPairs);
+  const plaintext = await buildPayload(store, waVersion, useToken, extraPairs, path);
   return sendEncrypted(path, plaintext, store, waVersion);
 }
 
@@ -1741,7 +1840,14 @@ 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, device);
+  // The ENC plaintext is also the URL query: the native client submits every
+  // parameter twice, in the clear and encrypted, byte for byte identical. This
+  // is documented and verified only for the Android /code and /register
+  // requests, so the mirror is scoped to them; iOS and the funnel endpoints
+  // keep posting to a bare path, exactly as before.
+  const mirrorQuery = device.os === 'android' && (path === '/code' || path === '/register');
+  const result = await httpPost(path, body, waVersion, bodyAtt.authorizationHeader, device,
+    mirrorQuery ? plaintext : undefined);
   _whaDbg('[DBG] REG ← ' + path + ' ' +
     (result && result.status ? result.status : JSON.stringify(result).slice(0, 120)) +
     (result && result.reason ? ' reason=' + result.reason : ''));
@@ -1824,7 +1930,7 @@ async function sendFunnelLog(store, waVersion, currentScreen, actionTaken, event
       'in',              national,
       'lg',              'en',
       'lc',              'US',
-      'expid',           toBase64Url(store.deviceId),
+      'expid',           toBase64UrlNoPad(store.deviceId),
       'fdid',            fdid,
       'id',              toUrlHex(store.identityId),
       'current_screen',  currentScreen,
@@ -1856,7 +1962,7 @@ async function sendPrePnFunnelLog(store, waVersion, actionTaken, eventName) {
     const body = buildForm([
       'lg',              'en',
       'lc',              'US',
-      'expid',           toBase64Url(store.deviceId),
+      'expid',           toBase64UrlNoPad(store.deviceId),
       'fdid',            fdid,
       'id',              toUrlHex(store.identityId),
       'current_screen',  'enter_number',
@@ -2588,7 +2694,7 @@ async function verifyCode(store, code, opts) {
 module.exports = { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, fetchIosVersion, fetchAndroidVersion, fetchPlayVersion, fetchAndroidVersionLive, fetchWaVersion, currentVersionFor, refreshSessionVersion, clearVersionCache, tryLoadAndroidMaterial, compareVersions, parsePhone, getCountryMeta, assertRegistrationKeys, parseSocksProxy, socksProxyUrl };
 
 // The HTTP reader, exposed for tests. Not part of the public API.
-module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody };
+module.exports._http = { readHttpResponse, parseHttpResponse, decodeChunkedBody, decodeBody, reorderRegistrationPairs };
 
 // Token computation, exposed for tests. Not part of the public API.
 module.exports._token = { computeToken, androidMaterialPath, registrationHeaders, ensureAndroidMaterial, deviceForRegistration, buildVerifiedNameCertificate, buildPayload };

package/lib/Store.js

@@ -82,7 +82,11 @@ function createNewStore(phoneNumber, opts) {
 
   const registrationId = (crypto.randomBytes(2).readUInt16BE(0) & 0x3fff) + 1;
   const fdid           = uuidv4();
-  const deviceId       = crypto.randomBytes(16);
+  // expid goes on the wire as a UUID and WhatsApp reads its version/variant
+  // nibbles (the native client builds it with UUID.nameUUIDFromBytes/randomUUID).
+  // 16 fully random bytes land on a valid UUID shape only ~1 time in 16, so the
+  // server sees a malformed UUID; take the 16 bytes of a real v4 UUID instead.
+  const deviceId       = Buffer.from(uuidv4().replace(/-/g, ''), 'hex');
   const identityId     = crypto.randomBytes(16);
   // Device fingerprint fields the native client sends on /code (see
   // Registration.js): advertising id (UUID) and the 20-byte backup token.
@@ -358,7 +362,8 @@ function fromSixParts(sixParts) {
     },
     registrationId: (crypto.randomBytes(2).readUInt16BE(0) & 0x3fff) + 1,
     fdid:           uuidv4(),
-    deviceId:       crypto.randomBytes(16),
+    // expid must be a valid UUID on the wire — see createNewStore above.
+    deviceId:       Buffer.from(uuidv4().replace(/-/g, ''), 'hex'),
     identityId,
     advertisingId:  uuidv4(),
     backupToken:    crypto.randomBytes(20),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.33.26",
+  "version": "5.33.29",
   "description": "Node.js library for WhatsApp — register a number over SMS, or link as a companion by QR. Signal E2E encryption, media, groups, channels.",
   "author": "Kunboruto20",
   "main": "index.js",