whalibmob 5.24.2 → 5.25.0

package/README.md

@@ -3575,6 +3575,14 @@ whalibmob implements the full lifecycle to prevent this:
 
 Token storage uses the **LID JID** of the contact (e.g. `112345678901234@lid`) as the key — never the phone-number JID — matching WhatsApp's internal convention.
 
+**cstoken — the companion fallback.** When there is no `<tctoken>` for a recipient, the genuine client attaches a `<cstoken>` instead. Unlike a tctoken it is not granted per contact; it is computed locally:
+
+```
+cstoken = HMAC-SHA256(nctSalt, recipient-LID)
+```
+
+The `nctSalt` is an account-wide secret the server distributes over app state, so only a **companion (QR / pairing-code) session** ever holds one — a primary (SMS) session has none and sends no cstoken, exactly as the real primary does until it has minted its own. When a companion session receives the salt it fires a `nct_salt` event and persists it; from then on, any first DM without a tctoken carries a `<cstoken>` derived for that recipient's LID. Like the rest of this section it is fully automatic — there is nothing to call.
+
 <a id="account-restriction"></a>
 
 ### When 463 Means the Account Is Restricted

package/index.d.ts

@@ -688,6 +688,8 @@ export interface WhalibmobEvents {
   /** The server refused the client itself — `405` means the announced version is not accepted. */
   client_rejected: (r: { reason: string; location?: string; message?: string }) => void;
   version_update: (v: { from: string; to: string; source: string }) => void;
+  /** A companion session received the NCT salt (over app state) that cstoken is derived from. */
+  nct_salt: (s: { bytes: number }) => void;
   apk_material_stale: (m: { materialVersion: string; liveVersion: string; hint?: string }) => void;
   number_corrected: (n: { from: string; to: string }) => void;
 

package/lib/Client.js

@@ -2229,6 +2229,27 @@ class WhalibmobClient extends EventEmitter {
         case 'delete':
           this.emit('chat_removed', { jid, kind: what.kind, remote: true });
           break;
+        case 'nct_salt_sync': {
+          // The salt the cstoken fallback is derived from. The server
+          // distributes it into app state; a SET carries the bytes, a REMOVE
+          // withdraws it. Kept on the store so it survives a reconnect. Only a
+          // companion ever gets one, which is why cstoken is a companion-only
+          // thing — a primary has no salt on file and sends none, exactly as
+          // the real primary does until it has minted its own.
+          if (removed) {
+            if (this._store) { this._store.nctSalt = null; this._persistStore(); }
+            _whaDbg('[DBG] NCT_SALT cleared');
+          } else {
+            const salt = a.nctSaltSyncAction && a.nctSaltSyncAction.salt;
+            if (salt && salt.length && this._store) {
+              this._store.nctSalt = Buffer.from(salt).toString('base64');
+              this._persistStore();
+              _whaDbg('[DBG] NCT_SALT stored (' + salt.length + ' bytes)');
+              this.emit('nct_salt', { bytes: salt.length });
+            }
+          }
+          break;
+        }
         default:
           // Something the server tracks that this library does not model yet.
           // Reported rather than dropped, so it is visible that it happened.
@@ -2707,6 +2728,67 @@ class WhalibmobClient extends EventEmitter {
     return lid ? lid + device + '@lid' : null;
   }
 
+  // ─── cstoken ────────────────────────────────────────────────────────────────
+  //
+  // The anti-abuse token the genuine client attaches to a message when it has no
+  // trusted-contact token for the recipient. Unlike a tctoken it is not granted
+  // by the server per contact — it is computed locally:
+  //
+  //   cstoken = HMAC-SHA256(nctSalt, recipient LID)
+  //
+  // The salt is account-wide and arrives over app state, so only a companion
+  // ever holds one. A primary (an SMS session) has no salt on file and sends no
+  // cstoken, which is what the real primary does until it has minted its own.
+  //
+  // This mirrors whatsmeow's generateCsToken line for line: a regular user, not
+  // the PSA account and not a bot; the recipient resolved to a LID; the HMAC
+  // taken over that LID's bare `user@lid` string.
+
+  /** The stored NCT salt as bytes, or null when this session has none. */
+  _nctSalt() {
+    const b64 = this._store && this._store.nctSalt;
+    if (!b64) return null;
+    try { const b = Buffer.from(b64, 'base64'); return b.length ? b : null; }
+    catch (_) { return null; }
+  }
+
+  /**
+   * The recipient's bare LID (`user@lid`), or null when there is no mapping.
+   *
+   * A JID already on the LID server is used as-is; a phone JID is resolved
+   * through the same PN→LID map every send uses. Device and agent parts are
+   * dropped — the token is taken over the non-AD address, as whatsmeow does.
+   */
+  _bareLidFor(jid) {
+    if (!jid) return null;
+    const str  = String(jid);
+    const user = str.split('@')[0].split(':')[0];
+    if (!user) return null;
+    if (str.endsWith('@lid')) return user + '@lid';
+    const lid = this._pnToLid && this._pnToLid.get(user);
+    return lid ? lid + '@lid' : null;
+  }
+
+  /**
+   * The cstoken bytes for a recipient, or null when none should be sent.
+   *
+   * Returns null — so no `<cstoken>` is attached — unless a salt is on file,
+   * the recipient is a regular user, and a LID resolves for them. Every one of
+   * those is a reason the genuine client also sends nothing.
+   */
+  _csTokenFor(jid) {
+    const salt = this._nctSalt();
+    if (!salt) return null;
+
+    const { isRegularTcTokenUser } = require('./messages/TcTokenStore');
+    if (!isRegularTcTokenUser(jid)) return null;
+
+    const lidJid = this._bareLidFor(jid);
+    if (!lidJid) return null;
+
+    return crypto.createHmac('sha256', salt).update(lidJid, 'utf8').digest();
+  }
+
   // Every address this message's session might be filed under, best first.
   _signalJidCandidates(from, participant, senderPn) {
     const out = [];

package/lib/WebStore.js

@@ -63,7 +63,9 @@ function webStoreToJson(store) {
     platform:    store.platform    || null,
     webVersion:  store.webVersion  || WEB_VERSION_FALLBACK.slice(),
     browser:     store.browser     || WEB_BROWSER.slice(),
-    syncFullHistory: store.syncFullHistory !== false
+    syncFullHistory: store.syncFullHistory !== false,
+    // The NCT salt (base64) a cstoken is derived from, received over app state.
+    nctSalt:     store.nctSalt     || null
   });
 }
 
@@ -87,6 +89,7 @@ function webStoreFromJson(obj) {
   store.webVersion  = obj.webVersion  || WEB_VERSION_FALLBACK.slice();
   store.browser     = obj.browser     || WEB_BROWSER.slice();
   store.syncFullHistory = obj.syncFullHistory !== false;
+  store.nctSalt     = obj.nctSalt     || null;
 
   return store;
 }

package/lib/appstate/Mutations.js

@@ -96,6 +96,8 @@ function describeIndex(index) {
     case 'setting_pushName':return { kind: 'pushName' };
     case 'clearChat':       return { kind: 'clear',    jid };
     case 'deleteChat':      return { kind: 'delete',   jid };
+    // Account-wide, no jid: the salt the cstoken fallback is derived from.
+    case 'nct_salt_sync':   return { kind: 'nct_salt_sync' };
     default:                return { kind, jid };
   }
 }

package/lib/appstate/SyncdProto.js

@@ -125,7 +125,10 @@ const ACTION_FIELDS = {
   17: 'archiveChatAction',
   20: 'markChatAsReadAction',
   21: 'clearChatAction',
-  22: 'deleteChatAction'
+  22: 'deleteChatAction',
+  // NctSaltSyncAction { salt = 1 }. The salt a cstoken is derived from; the
+  // server distributes it into app state and a companion reads it from here.
+  80: 'nctSaltSyncAction'
 };
 
 function decodeSyncActionValue(buf) {
@@ -156,6 +159,8 @@ function decodeSyncActionValue(buf) {
         out.clearChatAction = {}; break;
       case 'deleteChatAction':
         out.deleteChatAction = {}; break;
+      case 'nctSaltSyncAction':
+        out.nctSaltSyncAction = { salt: Buffer.isBuffer(a[1]) ? a[1] : null }; break;
       case 'pushNameSetting':
         out.pushNameSetting = { name: _str(a[1]) }; break;
       case 'contactAction':

package/lib/messages/MessageSender.js

@@ -1119,11 +1119,13 @@ class MessageSender {
       await this._client.ensureTcTokenBeforeSend(tcJid, routingToJid);
     }
 
+    let tcTokenAttached = false;
     if (tcStore) {
       const tcEntry = tcStore.get(tcJid);
       if (tcEntry && tcEntry.token && tcEntry.token.length) {
         if (!tcTokenExpired(tcEntry.timestamp)) {
           msgContent.push(new BinaryNode('tctoken', {}, tcEntry.token));
+          tcTokenAttached = true;
           _whaDbg('[DBG] TCTOKEN_ATTACH jid=' + tcJid);
         } else {
           // Expired token — clear it, keep senderTimestamp for dedupe
@@ -1132,6 +1134,19 @@ class MessageSender {
         }
       }
     }
+
+    // cstoken — the fallback the genuine client attaches when it has no
+    // trusted-contact token. Locally computed HMAC over the recipient's LID; a
+    // companion holds the salt, a primary does not, so this is a no-op on an SMS
+    // session. Never on a protocol message, and never alongside a tctoken —
+    // exactly the `if tctoken … else if cstoken …` the real client does.
+    if (!tcTokenAttached && !isProtocolMsg) {
+      const cs = this._client._csTokenFor(routingToJid);
+      if (cs && cs.length) {
+        msgContent.push(new BinaryNode('cstoken', {}, cs));
+        _whaDbg('[DBG] CSTOKEN_ATTACH jid=' + tcJid);
+      }
+    }
     // ─────────────────────────────────────────────────────────────────────────
 
     // Extra children a caller needs on the stanza — the <meta appdata> a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.24.2",
+  "version": "5.25.0",
   "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",