whalibmob 5.7.0 → 5.7.2

package/README.md

@@ -150,6 +150,7 @@ npm install -g whalibmob
     - [Handling Reconnects](#handling-reconnects)
     - [Knowing Which Mode You Are In](#knowing-which-mode-you-are-in)
     - [Two Sessions on One Number](#two-sessions-on-one-number)
+  - [The Number WhatsApp Files Your Account Under](#the-number-whatsapp-files-your-account-under)
   - [Routing Registration Through a Proxy](#routing-registration-through-a-proxy)
   - [Saving & Restoring Sessions](#saving--restoring-sessions)
   - [Signal Store Utilities](#signal-store-utilities)
@@ -807,6 +808,53 @@ await client.connectWeb(PHONE)  // web / companion, over WebSocket
 
 Use two `WhalibmobClient` instances if you want both at once.
 
+## The Number WhatsApp Files Your Account Under
+
+WhatsApp does not always keep an account under the number you type. Brazilian mobiles are the standing example: they gained a ninth digit, and WhatsApp keeps older accounts under the eight-digit form. `5596976042705` and `559676042705` are the same account, but only the second is the one the server recognises.
+
+This matters because the number in your session is sent as the username on every connection. Get the form wrong and the server has no registration matching it, so the login is refused with `401` — a code that says "logged out" and gives no hint that the number was the problem.
+
+whalibmob handles this on its own, in both directions:
+
+**When you register**, the canonical form is read from the server's reply and the session is saved under it. Numbers registered through whalibmob cannot end up in this state.
+
+**When you connect** an older session that is in this state, the first login is refused, whalibmob asks the server which form it uses, re-files the session, and connects. You see one line:
+
+```
+connecting to +5596976042705...
+  this account is registered as +559676042705 (not +5596976042705) — session updated
+connected as +559676042705
+```
+
+The rename keeps the registration and the Signal keys — it moves the session files, it does not re-register anything.
+
+```js
+client.on('number_corrected', ({ from, to }) => {
+  console.log('session re-filed:', from, '→', to)
+})
+```
+
+To be told rather than fixed:
+
+```js
+const client = new WhalibmobClient({ sessionDir, autoFixNumber: false })
+```
+
+Then the `401` is thrown as-is, and `checkSessionAlive()` tells you what the server calls the account:
+
+```js
+const probe = await client.checkSessionAlive()
+// { alive: true, status: 'ok', current: '5596976042705',
+//   canonical: '559676042705', mismatch: true }
+
+if (probe.mismatch) {
+  await client.adoptCanonicalNumber(probe.canonical)
+}
+```
+
+> [!NOTE]
+> The check costs nothing when things work — it runs only after a login has already been refused.
+
 ## Routing Registration Through a Proxy
 
 Registration is the part of the protocol most likely to be refused from a datacenter IP. If you are seeing security blocks or an undeterminable number status, route it through a SOCKS proxy — Tor, or a residential provider.

package/cli.js

@@ -747,6 +747,14 @@ async function doConnect(phone) {
   const client = new WhalibmobClient({ sessionDir: _sessDir });
   attachEvents(client);
 
+  // The session may be re-filed mid-connect when WhatsApp turns out to keep the
+  // account under a different form of the number. Everything from here on has
+  // to use the corrected one, including the prompt.
+  client.on('number_corrected', ({ from, to }) => {
+    phone = to;
+    out('  this account is registered as +' + to + ' (not +' + from + ') — session updated');
+  });
+
   client.once('connected', () => {
     _client = client;
     _phone  = phone;
@@ -783,19 +791,17 @@ async function doConnect(phone) {
         const probe = await client.checkSessionAlive();
 
         if (probe.mismatch) {
-          // The session is filed under a number the server does not use for
-          // this account, so the handshake has been sending a username no
-          // registration matches. Renaming fixes it; re-registering would not.
+          // Reached only when the automatic correction inside init() could not
+          // run — a session already exists under the canonical number, or the
+          // rename failed. Say what it would have done.
           hr();
           out('  the session is filed under a number WhatsApp does not use');
           out('    session : +' + probe.current);
           out('    server  : +' + probe.canonical);
           hr();
-          out('  WhatsApp knows this account by the second form, so every login');
-          out('  has been sent under a number it has no registration for.');
-          out('');
-          out('  fix it in place:  /fixnumber');
-          out('  (renames the session files, keeps the registration)');
+          out('  this is normally corrected automatically; it could not be here.');
+          out('  check whether a session for +' + probe.canonical + ' already exists,');
+          out('  then:  /fixnumber');
         } else if (probe.alive) {
           out('  the number IS still registered, but this device was logged out.');
           out('  register it again:  /reg code ' + phone);

package/lib/Client.js

@@ -203,6 +203,11 @@ class WhalibmobClient extends EventEmitter {
     // client the server will not accept. Suppresses the reconnect loop.
     this._fatal          = false;
     this._closing        = false;
+    // A session whose number is not in WhatsApp's canonical form is re-filed
+    // automatically on the first refused login. Set { autoFixNumber: false } to
+    // be told about it instead.
+    this._autoFixNumber  = opts.autoFixNumber !== false;
+    this._numberFixAttempted = false;
     this._pingTimer               = null;
     this._keepTimer               = null;
     this._connected     = false;
@@ -316,10 +321,83 @@ class WhalibmobClient extends EventEmitter {
     }
     _whaDbg('[DBG] LID_RESTORED count=' + Object.keys(persistedLid).length);
 
-    await this._connectSocket();
+    try {
+      await this._connectSocket();
+    } catch (err) {
+      // A session filed under a number WhatsApp does not use fails here and
+      // only here, with a 401 that says nothing about the number. Since we can
+      // ask the server which form it uses, there is no reason to make anyone
+      // find that out by hand.
+      const fixed = await this._tryCorrectPhoneNumber(err);
+      if (!fixed) throw err;
+      return this.init(fixed);
+    }
     return this;
   }
 
+  /**
+   * Last resort before reporting a refused login: check whether the session is
+   * simply filed under the wrong form of the number, and re-file it if so.
+   *
+   * Returns the corrected number when it did something, null otherwise. Only
+   * ever runs once per client — a second 401 after a rename is a real one.
+   */
+  async _tryCorrectPhoneNumber(err) {
+    if (this._autoFixNumber === false) return null;
+    if (this._numberFixAttempted) return null;
+    if (!err || !err.loggedOut || String(err.code) !== '401') return null;
+    this._numberFixAttempted = true;
+
+    let probe;
+    try {
+      probe = await this.checkSessionAlive();
+    } catch (_) {
+      return null;
+    }
+    if (!probe || !probe.mismatch || !probe.canonical) return null;
+
+    _whaDbg('[DBG] AUTO_FIX_NUMBER ' + probe.current + ' → ' + probe.canonical);
+
+    // Let go of the session files before moving them. The Signal store writes
+    // on a debounce, so a pending write would recreate the old file moments
+    // after the rename and leave two half-sessions on disk.
+    this._releaseSessionFiles();
+
+    try {
+      await this.adoptCanonicalNumber(probe.canonical);
+    } catch (renameErr) {
+      _whaDbg('[DBG] AUTO_FIX_NUMBER failed: ' + renameErr.message);
+      return null;
+    }
+
+    this.emit('number_corrected', {
+      from: probe.current,
+      to:   probe.canonical,
+      reason: 'WhatsApp files this account under a different form of the number'
+    });
+    return probe.canonical;
+  }
+
+  // Flush and detach whatever is holding the current session's files open, so
+  // they can be renamed without a queued write putting one of them back.
+  _releaseSessionFiles() {
+    for (const store of [this._signal && this._signal.store,
+                         this._signal && this._signal.senderKeyStore]) {
+      if (!store) continue;
+      try {
+        if (typeof store.detach === 'function') store.detach();
+        else {
+          if (typeof store._flushSync === 'function') store._flushSync();
+          if (store._saveTimer) { clearTimeout(store._saveTimer); store._saveTimer = null; }
+          store._filePath = null;
+        }
+      } catch (_) {}
+    }
+    this._signal       = null;
+    this._devMgr       = null;
+    this._tcTokenStore = null;
+  }
+
   async _connectSocket() {
     if (this._mode === 'web') return this._connectWebSocket();
 

package/lib/messages/MessageSender.js

@@ -25,6 +25,7 @@ const { uploadMedia } = require('../MediaService');
 const { imageThumbnail, videoThumbnail, probeImageSize } = require('../MediaThumbnail');
 const { tcTokenExpired, shouldSendNewTcToken, normalizeJidForTcToken,
         isRegularTcTokenUser } = require('./TcTokenStore');
+const { buildReportingNode } = require('./ReportingToken');
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -1014,6 +1015,19 @@ class MessageSender {
       msgContent = [...devIdNodes, participantsNode];
     }
 
+    // ─── Reporting token ─────────────────────────────────────────────────────
+    // Rides on any message carrying a message secret, so a recipient can report
+    // it and have the server verify the reported text is what was actually
+    // sent. Sending the secret without the token is a combination no real
+    // client produces.
+    const reportingNode = buildReportingNode({
+      plaintext, msgId, remoteJid: routingToJid, BinaryNode
+    });
+    if (reportingNode) {
+      msgContent.push(reportingNode);
+      _whaDbg('[DBG] REPORTING_TOKEN attached to=' + routingToJid + ' id=' + msgId);
+    }
+
     // ─── tcToken (error 463 / reachout timelock defense) ─────────────────────
     // WhatsApp counts every DM without a <tctoken> node as a "reaching out"
     // event. Once enough accumulate the server returns error 463 (timelock).
@@ -1372,6 +1386,17 @@ class MessageSender {
     if (mediaSubtype) skmsgAttrs.mediatype = mediaSubtype;
     msgContent.push(new BinaryNode('enc', skmsgAttrs, Buffer.isBuffer(skmsgCiphertext) ? skmsgCiphertext : Buffer.from(skmsgCiphertext)));
 
+    // Same reporting token a direct message carries. A poll posted to a group
+    // is the common case: it has a message secret, so it needs the token that
+    // lets a report on it be verified.
+    const groupReportingNode = buildReportingNode({
+      plaintext, msgId, remoteJid: groupJid, BinaryNode
+    });
+    if (groupReportingNode) {
+      msgContent.push(groupReportingNode);
+      _whaDbg('[DBG] REPORTING_TOKEN attached to=' + groupJid + ' id=' + msgId);
+    }
+
     // phash belongs on a group stanza and only on a group stanza — whatsmeow's
     // sendGroup sets it, sendDM does not. It tells the server which device set we
     // fanned out to; the server compares it against its own and echoes its hash

package/lib/messages/ReportingToken.js

@@ -0,0 +1,364 @@
+'use strict';
+
+// The reporting token that rides on messages carrying a message secret.
+//
+// It exists so a message can be reported for abuse without the server being
+// able to read it. The sender attaches an HMAC over the message's own content,
+// keyed by material derived from the message secret. If the recipient later
+// reports the message, they hand the server the plaintext; the server cannot
+// decrypt anything itself, but it can recompute the HMAC and confirm the text
+// being reported is exactly what was sent rather than something the reporter
+// made up.
+//
+// The HMAC is not taken over the whole message. WhatsApp hashes a fixed subset
+// of protobuf fields — the ones that carry reportable content — copied out in
+// field-number order, so that fields which vary between devices or over time do
+// not change the token. REPORTING_FIELDS below is that subset, and it is the
+// part that has to match byte for byte or the token is worthless.
+//
+// Ported field-for-field from Baileys' reporting-utils. whatsmeow derives the
+// key from (ownID, to) where Baileys uses the destination JID for both halves;
+// the reference followed here is Baileys, and since the server only checks the
+// token when a report is actually filed, neither choice is observable on send.
+
+const crypto     = require('crypto');
+const { hkdf }   = require('@noble/hashes/hkdf');
+const { sha256 } = require('@noble/hashes/sha256');
+
+// Protobuf field numbers on Message that the token is computed over.
+//   f  field number
+//   m  descend into it but keep every subfield
+//   s  descend into it and keep only these subfields
+const REPORTING_FIELDS = [
+  { f: 1 },
+  { f: 3,  s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }] },
+  { f: 4,  s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+  { f: 5,  s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+  { f: 6,  s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
+  { f: 7,  s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+  { f: 8,  s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
+  { f: 9,  s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+  { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
+  { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+  { f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+  { f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
+  { f: 37, s: [{ f: 1, m: true }] },
+  { f: 49, s: [{ f: 2 }, { f: 3, s: [{ f: 1 }, { f: 2 }] }, { f: 5, s: [{ f: 21 }, { f: 22 }] },
+               { f: 8, s: [{ f: 1 }, { f: 2 }] }] },
+  { f: 53, s: [{ f: 1, m: true }] },
+  { f: 55, s: [{ f: 1, m: true }] },
+  { f: 58, s: [{ f: 1, m: true }] },
+  { f: 59, s: [{ f: 1, m: true }] },
+  { f: 60, s: [{ f: 2 }, { f: 3, s: [{ f: 1 }, { f: 2 }] }, { f: 5, s: [{ f: 21 }, { f: 22 }] },
+               { f: 8, s: [{ f: 1 }, { f: 2 }] }] },
+  { f: 64, s: [{ f: 2 }, { f: 3, s: [{ f: 1 }, { f: 2 }] }, { f: 5, s: [{ f: 21 }, { f: 22 }] },
+               { f: 8, s: [{ f: 1 }, { f: 2 }] }] },
+  { f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+  { f: 74, s: [{ f: 1, m: true }] },
+  { f: 87, s: [{ f: 1, m: true }] },
+  { f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
+  { f: 92, s: [{ f: 1, m: true }] },
+  { f: 93, s: [{ f: 1, m: true }] },
+  { f: 94, s: [{ f: 1, m: true }] }
+];
+
+function compileFields(fields) {
+  const map = new Map();
+  for (const f of fields) {
+    map.set(f.f, { m: f.m, children: f.s ? compileFields(f.s) : undefined });
+  }
+  return map;
+}
+
+const COMPILED  = compileFields(REPORTING_FIELDS);
+const EMPTY_MAP = new Map();
+
+const ENC_SECRET_REPORT_TOKEN = 'Report Token';
+
+const WIRE = { VARINT: 0, FIXED64: 1, BYTES: 2, FIXED32: 5 };
+
+// Message field numbers that matter here.
+const F_MESSAGE_CONTEXT_INFO   = 35;
+const F_REACTION               = 46;
+const F_POLL_UPDATE            = 50;
+const F_ENC_REACTION           = 56;
+const F_ENC_EVENT_RESPONSE     = 76;
+const F_CTX_MESSAGE_SECRET     = 3;   // inside MessageContextInfo
+
+// ─── varints ─────────────────────────────────────────────────────────────────
+
+function decodeVarint(buffer, offset) {
+  let value = 0, bytes = 0, shift = 0;
+  while (offset + bytes < buffer.length) {
+    const current = buffer[offset + bytes];
+    value |= (current & 0x7f) << shift;
+    bytes++;
+    if ((current & 0x80) === 0) return { value, bytes, ok: true };
+    shift += 7;
+    if (shift > 35) return { value: 0, bytes: 0, ok: false };
+  }
+  return { value: 0, bytes: 0, ok: false };
+}
+
+function encodeVarint(value) {
+  const parts = [];
+  let remaining = value >>> 0;
+  while (remaining > 0x7f) {
+    parts.push((remaining & 0x7f) | 0x80);
+    remaining >>>= 7;
+  }
+  parts.push(remaining);
+  return Buffer.from(parts);
+}
+
+// ─── selective protobuf extraction ───────────────────────────────────────────
+//
+// Walks the encoded message and copies out only the configured fields, keeping
+// their original bytes. Length-delimited fields with a config of their own are
+// re-encoded around whatever their own walk produced, so a nested field that
+// contributes nothing disappears entirely rather than leaving an empty wrapper.
+//
+// The result is sorted by field number, which is what makes the token
+// independent of the order the encoder happened to write the fields in.
+//
+// Returns null on malformed input — the caller then attaches no token, which is
+// the same thing Baileys does.
+function extractReportingTokenContent(data, cfg) {
+  const out = [];
+  let i = 0;
+
+  while (i < data.length) {
+    const tag = decodeVarint(data, i);
+    if (!tag.ok) return null;
+
+    const fieldNum = tag.value >> 3;
+    const wireType = tag.value & 0x7;
+    const fieldStart = i;
+    i += tag.bytes;
+
+    const fieldCfg = cfg.get(fieldNum);
+
+    const pushSlice = (end) => {
+      if (end > data.length) return false;
+      out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) });
+      i = end;
+      return true;
+    };
+    const skip = (end) => {
+      if (end > data.length) return false;
+      i = end;
+      return true;
+    };
+
+    if (wireType === WIRE.VARINT) {
+      const v = decodeVarint(data, i);
+      if (!v.ok) return null;
+      const end = i + v.bytes;
+      if (!fieldCfg) { if (!skip(end)) return null; continue; }
+      if (!pushSlice(end)) return null;
+      continue;
+    }
+
+    if (wireType === WIRE.FIXED64) {
+      const end = i + 8;
+      if (!fieldCfg) { if (!skip(end)) return null; continue; }
+      if (!pushSlice(end)) return null;
+      continue;
+    }
+
+    if (wireType === WIRE.FIXED32) {
+      const end = i + 4;
+      if (!fieldCfg) { if (!skip(end)) return null; continue; }
+      if (!pushSlice(end)) return null;
+      continue;
+    }
+
+    if (wireType === WIRE.BYTES) {
+      const len = decodeVarint(data, i);
+      if (!len.ok) return null;
+      const valStart = i + len.bytes;
+      const valEnd   = valStart + len.value;
+      if (valEnd > data.length) return null;
+
+      if (!fieldCfg) { i = valEnd; continue; }
+
+      if (fieldCfg.m || fieldCfg.children) {
+        const sub = extractReportingTokenContent(
+          data.subarray(valStart, valEnd), fieldCfg.children || EMPTY_MAP
+        );
+        if (sub === null) return null;
+        if (sub.length > 0) {
+          out.push({
+            num: fieldNum,
+            bytes: Buffer.concat([encodeVarint(tag.value), encodeVarint(sub.length), sub])
+          });
+        }
+        i = valEnd;
+        continue;
+      }
+
+      out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) });
+      i = valEnd;
+      continue;
+    }
+
+    return null;
+  }
+
+  if (out.length === 0) return Buffer.alloc(0);
+  out.sort((a, b) => a.num - b.num);
+  return Buffer.concat(out.map(f => f.bytes));
+}
+
+// ─── key derivation ──────────────────────────────────────────────────────────
+//
+// The same construction WhatsApp uses for every secret derived from a message
+// secret — poll votes, reactions, and this. The use-case string is what keeps
+// them from colliding.
+function generateMsgSecretKey(modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) {
+  const useCaseSecret = Buffer.concat([
+    Buffer.from(String(origMsgId), 'utf8'),
+    Buffer.from(String(origMsgSender), 'utf8'),
+    Buffer.from(String(modificationSender), 'utf8'),
+    Buffer.from(modificationType, 'utf8')
+  ]);
+  return Buffer.from(hkdf(sha256, origMsgSecret, Buffer.alloc(32), useCaseSecret, 32));
+}
+
+// ─── reading what we need out of the encoded message ─────────────────────────
+
+// Shallow scan for the top-level field numbers present, plus the message
+// secret if MessageContextInfo carries one. Avoids decoding the whole message
+// just to answer two questions about it.
+function inspectMessage(plaintext) {
+  const present = new Set();
+  let messageSecret = null;
+  let i = 0;
+
+  while (i < plaintext.length) {
+    const tag = decodeVarint(plaintext, i);
+    if (!tag.ok) return { present, messageSecret, ok: false };
+    const fieldNum = tag.value >> 3;
+    const wireType = tag.value & 0x7;
+    i += tag.bytes;
+    present.add(fieldNum);
+
+    if (wireType === WIRE.VARINT) {
+      const v = decodeVarint(plaintext, i);
+      if (!v.ok) return { present, messageSecret, ok: false };
+      i += v.bytes;
+    } else if (wireType === WIRE.FIXED64) {
+      i += 8;
+    } else if (wireType === WIRE.FIXED32) {
+      i += 4;
+    } else if (wireType === WIRE.BYTES) {
+      const len = decodeVarint(plaintext, i);
+      if (!len.ok) return { present, messageSecret, ok: false };
+      const valStart = i + len.bytes;
+      const valEnd   = valStart + len.value;
+      if (valEnd > plaintext.length) return { present, messageSecret, ok: false };
+      if (fieldNum === F_MESSAGE_CONTEXT_INFO) {
+        messageSecret = readMessageSecret(plaintext.subarray(valStart, valEnd));
+      }
+      i = valEnd;
+    } else {
+      return { present, messageSecret, ok: false };
+    }
+  }
+  return { present, messageSecret, ok: true };
+}
+
+function readMessageSecret(ctxBuf) {
+  let i = 0;
+  while (i < ctxBuf.length) {
+    const tag = decodeVarint(ctxBuf, i);
+    if (!tag.ok) return null;
+    const fieldNum = tag.value >> 3;
+    const wireType = tag.value & 0x7;
+    i += tag.bytes;
+
+    if (wireType === WIRE.VARINT) {
+      const v = decodeVarint(ctxBuf, i);
+      if (!v.ok) return null;
+      i += v.bytes;
+    } else if (wireType === WIRE.FIXED64) {
+      i += 8;
+    } else if (wireType === WIRE.FIXED32) {
+      i += 4;
+    } else if (wireType === WIRE.BYTES) {
+      const len = decodeVarint(ctxBuf, i);
+      if (!len.ok) return null;
+      const valStart = i + len.bytes;
+      const valEnd   = valStart + len.value;
+      if (valEnd > ctxBuf.length) return null;
+      if (fieldNum === F_CTX_MESSAGE_SECRET) return ctxBuf.subarray(valStart, valEnd);
+      i = valEnd;
+    } else {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Whether a message of this shape carries a reporting token at all.
+ *
+ * Reactions and poll votes are excluded: they are modifications of somebody
+ * else's message, and the token belongs to the message being modified.
+ */
+function shouldIncludeReportingToken(present) {
+  return !present.has(F_REACTION) &&
+         !present.has(F_ENC_REACTION) &&
+         !present.has(F_ENC_EVENT_RESPONSE) &&
+         !present.has(F_POLL_UPDATE);
+}
+
+/**
+ * Build the <reporting> node for an outgoing message, or null when there is
+ * nothing to attach.
+ *
+ * @param {object} opts
+ *   plaintext    encoded Message protobuf, exactly as it will be encrypted
+ *   msgId        the stanza id
+ *   remoteJid    the destination JID
+ *   participant  set only on a targeted resend; undefined otherwise
+ *   BinaryNode   the node constructor
+ */
+function buildReportingNode(opts) {
+  const { plaintext, msgId, remoteJid, participant, BinaryNode } = opts;
+  if (!Buffer.isBuffer(plaintext) || !msgId || !remoteJid) return null;
+
+  const info = inspectMessage(plaintext);
+  if (!info.ok || !info.messageSecret || !info.messageSecret.length) return null;
+  if (!shouldIncludeReportingToken(info.present)) return null;
+
+  // fromMe is always true here — we only ever build this for our own sends.
+  const from = String(remoteJid);
+  const to   = String(participant || remoteJid);
+
+  const reportingSecret = generateMsgSecretKey(
+    ENC_SECRET_REPORT_TOKEN, msgId, from, to, info.messageSecret
+  );
+
+  const content = extractReportingTokenContent(plaintext, COMPILED);
+  if (!content || content.length === 0) return null;
+
+  const token = crypto.createHmac('sha256', reportingSecret)
+    .update(content).digest().subarray(0, 16);
+
+  return new BinaryNode('reporting', {}, [
+    new BinaryNode('reporting_token', { v: '2' }, token)
+  ]);
+}
+
+module.exports = {
+  buildReportingNode,
+  shouldIncludeReportingToken,
+  extractReportingTokenContent,
+  generateMsgSecretKey,
+  inspectMessage,
+  decodeVarint,
+  encodeVarint,
+  REPORTING_FIELDS,
+  COMPILED
+};

package/lib/signal/SenderKey.js

@@ -93,10 +93,26 @@ class SenderKeyStore {
     this._dirty     = false;
     this._saveTimer = null;
 
-    const flush = () => this._flushSync();
-    process.once('exit',    flush);
-    process.once('SIGTERM', () => { flush(); process.exit(0); });
-    process.once('SIGINT',  () => { flush(); process.exit(0); });
+    // Detachable, for the same reason as in SignalStore: a replaced store must
+    // not keep three process listeners alive for the rest of the run.
+    this._onExit    = () => this._flushSync();
+    this._onSigTerm = () => { this._flushSync(); process.exit(0); };
+    this._onSigInt  = () => { this._flushSync(); process.exit(0); };
+    process.once('exit',    this._onExit);
+    process.once('SIGTERM', this._onSigTerm);
+    process.once('SIGINT',  this._onSigInt);
+  }
+
+  /** Flush, stop writing, and stop holding the process open. */
+  detach() {
+    this._flushSync();
+    if (this._saveTimer) { clearTimeout(this._saveTimer); this._saveTimer = null; }
+    try {
+      process.removeListener('exit',    this._onExit);
+      process.removeListener('SIGTERM', this._onSigTerm);
+      process.removeListener('SIGINT',  this._onSigInt);
+    } catch (_) {}
+    this._filePath = null;
   }
 
   attachFile(filePath) {

package/lib/signal/SignalStore.js

@@ -36,11 +36,30 @@ class SignalStore {
     this._dirty            = false;
     this._saveTimer        = null;
 
-    // Flush synchronously on exit so no state is ever lost
-    const flush = () => this._flushSync();
-    process.once('exit',    flush);
-    process.once('SIGTERM', () => { flush(); process.exit(0); });
-    process.once('SIGINT',  () => { flush(); process.exit(0); });
+    // Flush synchronously on exit so no state is ever lost.
+    //
+    // Kept as references so they can be taken off again: a store that has been
+    // replaced — when a session is re-filed under a different number, say —
+    // would otherwise stay reachable from process forever, and every store ever
+    // built would add three more listeners.
+    this._onExit    = () => this._flushSync();
+    this._onSigTerm = () => { this._flushSync(); process.exit(0); };
+    this._onSigInt  = () => { this._flushSync(); process.exit(0); };
+    process.once('exit',    this._onExit);
+    process.once('SIGTERM', this._onSigTerm);
+    process.once('SIGINT',  this._onSigInt);
+  }
+
+  /** Flush, stop writing, and stop holding the process open. */
+  detach() {
+    this._flushSync();
+    if (this._saveTimer) { clearTimeout(this._saveTimer); this._saveTimer = null; }
+    try {
+      process.removeListener('exit',    this._onExit);
+      process.removeListener('SIGTERM', this._onSigTerm);
+      process.removeListener('SIGINT',  this._onSigInt);
+    } catch (_) {}
+    this._filePath = null;
   }
 
   init(identityKeyPair, registrationId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.7.0",
+  "version": "5.7.2",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",