whalibmob 5.5.57 → 5.5.60

package/README.md

@@ -4,10 +4,10 @@
 ##
 
 > [!IMPORTANT]
-> new repository whalibmob It will be maintained at the https://github.com/Kunboruto50/whalibmob.git Since I lost the Kunboruto20 account, whalibmob will be maintained and rewritten by me soon because I know that many functions in whalibmob no longer work after the WhatsApp mobile protocol change, these days I will take care of whalibmob, all good friends Fun enjoyable for all c
 
 
-CONTACT ME ON TELEGRAM  IF YOU WANT TO WORK WITH ME AND IF YOU HAVE PROBLEM WITH WHALIBMOB : @borutokun240
+
+CONTACT ME ON TELEGRAM  IF YOU WANT TO WORK WITH ME AND IF YOU HAVE PROBLEM WITH WHALIBMOB : @brtyu545
 
 TELEGRAM NEW WHALIBMOB CHANNEL JOIN HERE https://t.me/+jWzq-I9o0Xc1Mzc8
 
@@ -126,6 +126,7 @@ npm install -g whalibmob
 - [Library API](#library-api)
   - [Connecting Account](#connecting-account)
     - [Register a New Number](#register-a-new-number)
+    - [Device Attestation with Frida (optional)](#device-attestation-with-frida-optional)
     - [Connect](#connect)
   - [Saving & Restoring Sessions](#saving--restoring-sessions)
   - [Signal Store Utilities](#signal-store-utilities)
@@ -272,6 +273,113 @@ if (result.status === 'ok') {
 }
 ```
 
+### Device Attestation with Frida (optional)
+
+WhatsApp's registration servers score every `/code` and `/register` request on how
+much it looks like a genuine phone. A real device proves itself with a hardware
+attestation token — **Play Integrity** plus a **Keystore**-signed request on
+Android, **App Attest** on iOS. whalibmob sends these fields on every registration
+request, but it can only fill them with real values if it can talk to an actual
+device.
+
+This repository ships a **`frida/` folder** containing the on-device scripts that
+produce those tokens. It is entirely **optional**: with no device attached,
+whalibmob sends the same empty attestation fields a real phone sends when its
+integrity check fails, and registration still works. Attaching a device raises the
+trust score, which helps when you keep hitting `no_routes` or block screens.
+
+> Requires a **rooted Android phone** or a **jailbroken iPhone** with the official
+> WhatsApp app installed from the Play Store / App Store. Sideloaded APKs do not
+> work — the attestation is bound to the store-signed build.
+
+#### What's in the folder
+
+```
+frida/
+  android/     Play Integrity + Keystore attestation server  (/integrity, /cert, /info)
+  ios/         App Attest attestation server                 (/integrity)
+```
+
+Each platform folder has its own `README.md` with the full device prerequisites.
+
+#### 1. Build the script
+
+Install [Frida](https://frida.re) on your computer, then build the bundle for your
+platform:
+
+```bash
+cd frida/android      # or: cd frida/ios
+npm install
+npm run build         # produces server_with_dependencies.js
+```
+
+#### 2. Run it on the device
+
+Make sure the Frida server is running on the phone, then attach to WhatsApp:
+
+```bash
+# Android — open WhatsApp and reach the "register a number" screen FIRST,
+# otherwise the integrity components are not loaded yet
+frida -U "WhatsApp" -l server_with_dependencies.js
+
+# iOS
+frida -U -l server_with_dependencies.js -f "net.whatsapp.WhatsApp"
+```
+
+The script starts a small HTTP server **on the phone**, listening on port `1119`
+(or `1120` if you attached to WhatsApp Business). Wait for:
+
+```
+[*] Server ready on port 1119
+```
+
+#### 3. Make the port reachable
+
+whalibmob talks to that server over plain HTTP, so the port has to be reachable
+from the machine running your bot. Over USB, forward it with adb:
+
+```bash
+adb forward tcp:1119 tcp:1119     # Android
+iproxy 1119 1119                  # iOS (libimobiledevice)
+```
+
+Alternatively, if the phone is on the same Wi-Fi, use its LAN IP directly.
+
+#### 4. Point whalibmob at it
+
+Set the host — and the port, if it isn't the default `1119`:
+
+```bash
+WA_FRIDA_HOST=127.0.0.1
+WA_FRIDA_PORT=1119        # optional; use 1120 for WhatsApp Business
+```
+
+Or in `.env`:
+
+```
+WA_FRIDA_HOST=127.0.0.1
+WA_FRIDA_PORT=1119
+```
+
+That is the whole integration. On the next `requestSmsCode()` / `verifyCode()`
+call, whalibmob queries the device automatically and attaches the attestation to
+the request:
+
+| Platform | Fields it fills                                                    |
+|----------|--------------------------------------------------------------------|
+| Android  | `gpia` (Play Integrity) in the body, plus a Keystore signature and certificate chain on the request |
+| iOS      | An App Attest assertion and attestation on the request              |
+
+Keep the Frida session open while you register. When you unset `WA_FRIDA_HOST`,
+whalibmob silently goes back to the empty-attestation path — no code changes, and
+nothing else in your bot is affected.
+
+> **Troubleshooting.** If the fields come back empty, check in this order: the
+> Frida session is still attached, the port is forwarded, and — on Android — that
+> you opened WhatsApp's registration screen at least once before attaching, since
+> the integrity components are lazy-loaded. whalibmob never fails a registration
+> because attestation is unavailable; it just falls back to empty values.
+
 ### Connect
 
 ```js

package/cli.js

@@ -37,7 +37,7 @@ const {
 
 const { assertMeId, initAuthCreds } = require('./lib/auth-utils');
 
-const VERSION = '5.1.21';
+const VERSION = '5.5.59';
 
 // ─── output helpers ───────────────────────────────────────────────────────────
 

package/lib/Attestation.js

@@ -0,0 +1,212 @@
+'use strict';
+
+// ─── Device attestation client ────────────────────────────────────────────────
+//
+// Talks to the on-device Frida attestation server shipped in ./frida (Android
+// Play Integrity / Keystore attestation, iOS App Attest) and folds its output
+// into the registration request, mirroring how Auties00/cobalt consumes the
+// same scripts.
+//
+// Design (matches Cobalt's LinkedWhatsAppClientDeviceAttestor):
+//   • Two data shapes are produced —
+//       Android: { gpia, gg, gi, gp, ge, ga }  (Play Integrity legs)
+//       iOS:     { attestation, assertion, keyId }  (App Attest)
+//   • A NONE fallback returns empty strings for every field. The WhatsApp
+//     registration server tolerates empty attestation as a low-trust signal,
+//     so registration still works with no rooted/jailbroken device attached.
+//
+// Activation: set WA_FRIDA_HOST (e.g. 127.0.0.1) — and optionally WA_FRIDA_PORT
+// (default 1119 for WhatsApp consumer, 1120 for Business) — to make the client
+// query the local Frida server. When WA_FRIDA_HOST is unset every method
+// returns the empty NONE fallback and performs no network I/O.
+
+const crypto = require('crypto');
+const http   = require('http');
+
+const DEFAULT_PORT   = 1119;   // WhatsApp consumer; Business build listens on 1120
+const REQUEST_TIMEMS = 15000;
+
+// ─── Empty (NONE) fallbacks ───────────────────────────────────────────────────
+
+const EMPTY_ANDROID = { gpia: '', gg: '', gi: '', gp: '', ge: '', ga: '' };
+const EMPTY_IOS     = { attestation: '', assertion: '', keyId: '' };
+const EMPTY_BODY    = { bodyAttestation: null, authorizationHeader: null };
+
+function fridaHost() {
+  return process.env.WA_FRIDA_HOST || null;
+}
+
+function fridaPort() {
+  return parseInt(process.env.WA_FRIDA_PORT, 10) || DEFAULT_PORT;
+}
+
+function isEnabled() {
+  return !!fridaHost();
+}
+
+// ─── base64 / hex helpers ─────────────────────────────────────────────────────
+
+function toBase64Url(buf) {
+  return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+function sha256(buf) {
+  return crypto.createHash('sha256').update(buf).digest();
+}
+
+function toHex(buf) {
+  return Buffer.from(buf).toString('hex');
+}
+
+// ─── Local Frida HTTP GET (best-effort; never throws) ─────────────────────────
+// 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) {
+  return new Promise((resolve) => {
+    const host = fridaHost();
+    if (!host) return resolve(null);
+
+    const qs = query
+      ? '?' + Object.keys(query)
+          .filter(k => query[k] != null)
+          .map(k => k + '=' + encodeURIComponent(query[k]))
+          .join('&')
+      : '';
+
+    const req = http.request(
+      { host, port: fridaPort(), path: pathname + qs, method: 'GET', timeout: REQUEST_TIMEMS },
+      (res) => {
+        const chunks = [];
+        res.on('data', d => chunks.push(d));
+        res.on('end', () => {
+          try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8'))); }
+          catch (_) { resolve(null); }
+        });
+      }
+    );
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.end();
+  });
+}
+
+// ─── Android: Play Integrity legs (gpia + _gg _gi _gp _ge _ga) ────────────────
+//
+// Queries /integrity?authKey=<nonce>. The Frida server returns { token }, which
+// becomes the Play Integrity verdict token (gpia). The _gg/_gi/_gp/_ge/_ga GMS
+// legs are only produced by the full native attestor, so a Frida-only setup
+// leaves them empty — the server accepts a gpia-only attestation.
+//
+// nonceB64 is the URL-safe base64 request nonce (see attestationFieldsAndroid).
+async function androidIntegrity(nonceB64) {
+  if (!isEnabled()) return { ...EMPTY_ANDROID };
+  const res = await fridaGet('/integrity', { authKey: nonceB64 });
+  if (!res || !res.token) return { ...EMPTY_ANDROID };
+  return { gpia: res.token, gg: '', gi: '', gp: '', ge: '', ga: '' };
+}
+
+// ─── Android: Keystore attestation over the ENC body (&H= + Authorization) ────
+//
+// Queries /cert?authKey=<authKeyB64>&enc=<encB64>. Both parameters are decoded
+// with the STANDARD base64 decoder on the device, so they must not be URL-safe:
+//   authKey — the 32-byte raw auth key (the Noise public key, no 0x05 prefix);
+//             the server embeds it in the Keystore attestation challenge and
+//             locates it in the certificate by its 64-hex-char representation.
+//   enc     — the UTF-8 bytes of the ENC payload string, base64-encoded; the
+//             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) {
+  if (!isEnabled()) return { ...EMPTY_BODY };
+  const encParam = Buffer.from(encB64, 'utf8').toString('base64');
+  const res = await fridaGet('/cert', { authKey: authKeyB64, enc: encParam });
+  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() {
+  if (!isEnabled()) return null;
+  return fridaGet('/info');
+}
+
+// ─── iOS: App Attest (attestation + assertion + keyId) ────────────────────────
+//
+// Queries /integrity?authKey=<clientDataHashB64>. The Frida server returns
+// { 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) {
+  if (!isEnabled()) return { ...EMPTY_IOS };
+  const res = await fridaGet('/integrity', { authKey: noisePubB64 });
+  if (!res || !res.attestation || !res.assertion) return { ...EMPTY_IOS };
+  return {
+    attestation: res.attestation,
+    assertion:   res.assertion,
+    keyId:       res.keyId || ''
+  };
+}
+
+// ─── High-level: attestation fields shipped on every attested endpoint ────────
+//
+// Returns the alternating name/value pairs Cobalt ships via attestationFields():
+//   Android → gpia,_gg,_gi,_gp,_ge,_ga,push_token
+//   iOS     → push_token
+//
+// These fields are part of the plaintext that gets AES-GCM-sealed into the
+// ENC envelope, so the Play Integrity nonce is derived from the store (a stable
+// per-session value), NOT from the ENC body. pushToken comes from the optional
+// push client — empty by default.
+async function attestationFields(device, nonceB64, opts) {
+  opts = opts || {};
+  const pushToken = opts.pushToken || '';
+
+  if (device && device.os === 'android') {
+    const a = await androidIntegrity(nonceB64 || '');
+    return [
+      'gpia',       a.gpia,
+      '_gg',        a.gg,
+      '_gi',        a.gi,
+      '_gp',        a.gp,
+      '_ge',        a.ge,
+      '_ga',        a.ga,
+      'push_token', pushToken
+    ];
+  }
+
+  // iOS ships only push_token in the form body; App Attest rides in &H= + header.
+  return ['push_token', pushToken];
+}
+
+// ─── High-level: body attestation (&H= suffix + Authorization header) ─────────
+//
+// encB64       — the base64url ENC payload (without the "ENC=" prefix)
+// device       — { os }
+// keys.noisePubB64 — standard base64 of the 32-byte Noise public key. Android
+//                    uses it as the Keystore attestation challenge auth key;
+//                    iOS uses it as the App Attest clientDataHash source.
+async function attestBody(encB64, device, keys) {
+  keys = keys || {};
+  if (device && device.os === 'android') {
+    return androidAttestBody(encB64, keys.noisePubB64 || '');
+  }
+  const data = await iosAppAttest(keys.noisePubB64 || '');
+  if (!data.attestation || !data.assertion || !data.keyId) return { ...EMPTY_BODY };
+  return {
+    bodyAttestation:     '{"assertion":"' + data.assertion + '"}',
+    authorizationHeader: data.attestation + '|' + data.keyId
+  };
+}
+
+module.exports = {
+  isEnabled,
+  attestationFields,
+  attestBody,
+  androidInfo,
+  toHex,
+  toBase64Url,
+  EMPTY_ANDROID,
+  EMPTY_IOS,
+  EMPTY_BODY
+};

package/lib/Client.js

@@ -676,7 +676,7 @@ class WhalibmobClient extends EventEmitter {
     _whaDbg('[DBG] DM_DECRYPT id=' + id + ' type=' + encType + ' sigJid=' + sigJid + ' cipherLen=' + cipherBuf.length);
 
     this._signal.decrypt(sigJid, encType, cipherBuf)
-      .then(plaintext => {
+      .then(async plaintext => {
         const decoded = this._decodeMsg(plaintext);
         _whaDbg('[DBG] DM_DECODED id=' + id + ' type=' + decoded.type + ' ptLen=' + (plaintext ? plaintext.length : 0) + ' hasSKDM=' + !!(decoded.skdm || decoded.type === 'senderKeyDistribution'));
 
@@ -685,7 +685,7 @@ class WhalibmobClient extends EventEmitter {
         // axolotlBytes may be absent in newer WA proto versions — that's OK for DM pkmsg flow.
         if (decoded.skdm && decoded.skdm.axolotlBytes && decoded.skdm.axolotlBytes[0] === 0x33) {
           try {
-            this._signal.processSKDM(decoded.skdm.groupId, sigJid, decoded.skdm.axolotlBytes);
+            await this._signal.processSKDM(decoded.skdm.groupId, sigJid, decoded.skdm.axolotlBytes);
             _whaDbg('[DBG] SKDM_PROCESSED groupId=' + decoded.skdm.groupId + ' sender=' + sigJid);
           } catch (e) {
             _whaDbg('[DBG] SKDM_ERR ' + e.message);
@@ -696,7 +696,7 @@ class WhalibmobClient extends EventEmitter {
         if (decoded.type === 'senderKeyDistribution') {
           if (decoded.axolotlBytes && decoded.axolotlBytes[0] === 0x33) {
             try {
-              this._signal.processSKDM(decoded.groupId, sigJid, decoded.axolotlBytes);
+              await this._signal.processSKDM(decoded.groupId, sigJid, decoded.axolotlBytes);
               _whaDbg('[DBG] SKDM_ONLY_PROCESSED groupId=' + decoded.groupId + ' sender=' + sigJid);
             } catch (e) {
               _whaDbg('[DBG] SKDM_ONLY_ERR ' + e.message);
@@ -745,24 +745,25 @@ class WhalibmobClient extends EventEmitter {
       ? skmsgNode.content
       : Buffer.from(skmsgNode.content || '');
 
-    try {
-      const plaintext = this._signal.senderKeyDecrypt(from, participant, cipherBuf);
-      const decoded   = this._decodeMsg(plaintext);
-      if (decoded.type === 'senderKeyDistribution') return;
-      if (decoded.type === 'protocol') {
-        if (decoded.subtype === 'history_sync' && decoded.historySyncNotification) {
-          this._handleHistorySync(decoded.historySyncNotification, id);
-        }
-        if (decoded.subtype === 'app_state_sync_key_share' && decoded.appStateSyncKeyShare) {
-          this._handleAppStateSyncKeyShare(decoded.appStateSyncKeyShare);
+    this._signal.senderKeyDecrypt(from, participant, cipherBuf)
+      .then(plaintext => {
+        const decoded = this._decodeMsg(plaintext);
+        if (decoded.type === 'senderKeyDistribution') return;
+        if (decoded.type === 'protocol') {
+          if (decoded.subtype === 'history_sync' && decoded.historySyncNotification) {
+            this._handleHistorySync(decoded.historySyncNotification, id);
+          }
+          if (decoded.subtype === 'app_state_sync_key_share' && decoded.appStateSyncKeyShare) {
+            this._handleAppStateSyncKeyShare(decoded.appStateSyncKeyShare);
+          }
+          return;
         }
-        return;
-      }
-      this.emit('message', { id, from, participant, ts, decoded, isGroup: true, node });
-      this._sendReadReceipt(id, fromRaw, partRaw);
-    } catch (err) {
-      this.emit('decrypt_error', { id, from, participant, err });
-    }
+        this.emit('message', { id, from, participant, ts, decoded, isGroup: true, node });
+        this._sendReadReceipt(id, fromRaw, partRaw);
+      })
+      .catch(err => {
+        this.emit('decrypt_error', { id, from, participant, err });
+      });
   }
 
   _decodeMsg(buf) {
@@ -801,14 +802,14 @@ class WhalibmobClient extends EventEmitter {
 
       tasks.push(
         this._signal.decrypt(senderJid, encType, cipherBuf)
-          .then(decrypted => {
+          .then(async decrypted => {
             const decoded = this._decodeMsg(decrypted);
             if (decoded && decoded.type === 'senderKeyDistribution' &&
                 decoded.groupId && decoded.axolotlBytes) {
-              this._signal.processSKDM(decoded.groupId, senderJid, decoded.axolotlBytes);
+              await this._signal.processSKDM(decoded.groupId, senderJid, decoded.axolotlBytes);
             } else if (decoded && decoded.skdm &&
                        decoded.skdm.groupId && decoded.skdm.axolotlBytes) {
-              this._signal.processSKDM(decoded.skdm.groupId, senderJid, decoded.skdm.axolotlBytes);
+              await this._signal.processSKDM(decoded.skdm.groupId, senderJid, decoded.skdm.axolotlBytes);
             }
           })
           .catch(() => {})
@@ -1255,6 +1256,7 @@ class WhalibmobClient extends EventEmitter {
     const connNode = findChild(node, 'media_conn');
     if (!connNode) return;
     const auth  = (connNode.attrs && connNode.attrs.auth) || '';
+    const ttl   = connNode.attrs && connNode.attrs.ttl ? parseInt(connNode.attrs.ttl, 10) : 300;
     const hosts = [];
     if (Array.isArray(connNode.content)) {
       for (const child of connNode.content) {
@@ -1264,9 +1266,9 @@ class WhalibmobClient extends EventEmitter {
         }
       }
     }
-    this._mediaConn = { hosts, auth };
-    if (this._sender) this._sender.setMediaConnection(hosts, auth);
-    this.emit('media_conn', { hosts, auth });
+    this._mediaConn = { hosts, auth, ttl, fetchDate: Date.now() };
+    if (this._sender) this._sender.setMediaConnection(hosts, auth, ttl, Date.now());
+    this.emit('media_conn', { hosts, auth, ttl });
   }
 
   // ─── Pre-key upload ───────────────────────────────────────────────────────