whalibmob 5.14.15 → 5.14.17

package/.env.example

@@ -116,6 +116,13 @@
 # WA_ALLOW_FOREIGN_APK=1
 
 
+# ─── Flash call verification ─────────────────────────────────────────────────
+# --method flash has WhatsApp ring the number and hang up; the code is the last
+# digits of the number that called. Six is what the app defaults to; set this
+# only for a number whose server expects a different length.
+# WA_FLASH_CODE_LEN=6
+
+
 # ─── Proxy ───────────────────────────────────────────────────────────────────
 # Route registration traffic through a SOCKS proxy. Requires the `socks`
 # package: npm install socks

package/README.md

@@ -292,8 +292,41 @@ wa registration --request-code 919634847671 --method voice
 
 # via an old WhatsApp account
 wa registration --request-code 919634847671 --method wa_old
+
+# via flash call — WhatsApp rings the number and hangs up (Android only)
+WA_OS=android wa registration --request-code 919634847671 --method flash
+```
+
+**Flash call** sends no code anywhere. WhatsApp rings the number from a
+one-time number and drops the call before it can be answered, and the
+verification code *is* that number — its last 6 digits. The official Android app
+reads them out of the call log; here the person holding the phone reads the
+missed call instead and types them:
+
+```sh
+# phone shows a missed call from +40 21 555 123456
+wa registration --register 919634847671 --code 123456
 ```
 
+Pasting the whole number works too — only its last six digits are sent. Do not
+answer the call; it hangs up on its own, and answering it does not verify
+anything.
+
+Three things to know before choosing it:
+
+- **Android only.** iOS has no API for reading an incoming call's number, so
+  WhatsApp never offers flash there. Asking for it as iOS is refused before any
+  request goes out, so the number spends no attempt learning that.
+- **The server decides.** Flash is not offered for every number or country. When
+  it declines, the request falls back to SMS automatically and the session
+  records that, so the SMS code is confirmed as an SMS code rather than being
+  trimmed like a caller ID.
+- **The caller ID has to be visible.** A carrier that withholds the calling
+  number leaves nothing to read.
+
+Set `WA_FLASH_CODE_LEN` if a number's server expects a different length than the
+six digits the app defaults to.
+
 **Set the account's display name while registering** with `--name`. This is the
 name people who have *not* saved your number see next to it — in group
 participant lists, in notifications, and beside your messages. Quote it if it

package/cli.js

@@ -484,6 +484,26 @@ function normalizePhone(s) {
   return String(s || '').replace(/^\+/, '').replace(/\D/g, '');
 }
 
+// What to tell the person once a code request has gone through. A flash call
+// needs its own words: nothing arrives in a message, so "enter the code" names
+// something they will never receive. What they get is a call that stops before
+// it can be answered, and the code is the number it came from.
+//
+// The method printed is the one that actually went out — a flash request the
+// server declined and fell back to SMS has to say SMS, or the instructions
+// describe a call that is never coming.
+function printCodeNextSteps(store, phone, confirmCmd) {
+  if (store && store.codeMethod === 'flash') {
+    out('  a call will ring +' + phone + ' and hang up by itself — do not answer it');
+    out('  the code is the LAST 6 DIGITS of the number that called');
+    out('  pasting the whole number works too — only its last 6 digits are sent');
+    out('  run: ' + confirmCmd + ' <last-6-digits>');
+    return;
+  }
+  out('  important: enter the code within 10 minutes');
+  out('  run: ' + confirmCmd + ' <code>');
+}
+
 function normalizeJid(s) {
   if (!s) return null;
   s = String(s);
@@ -2236,7 +2256,7 @@ async function handleLine(line) {
           // email method: /reg code <phone> email <address>
           const emailAddr = method === 'email' ? (p[4] || '') : '';
           if (!ph) {
-            fail('usage: /reg code <phone> [sms|voice|wa_old|email <address>] [--name "Your Name"]');
+            fail('usage: /reg code <phone> [sms|voice|wa_old|flash|email <address>] [--name "Your Name"]');
             out('  --name sets the display name the account registers with — what people');
             out('  who have not saved your number see. It can be changed later with /name.');
             break;
@@ -2272,8 +2292,7 @@ async function handleLine(line) {
           store.codePending = true;
           saveStore(store, sessFile);
           out('  status  ' + (r && r.status));
-          out('  important: enter the code within 10 minutes');
-          out('  now run: /reg confirm ' + ph + ' <code>');
+          printCodeNextSteps(store, ph, '/reg confirm ' + ph);
         }
         else if (sub === 'confirm') {
           const ph   = normalizePhone(p[2]);
@@ -2544,7 +2563,9 @@ options:
   --out <file>      where apk-material writes  (default: <session dir>/android-apk-material.json)
   --sms             connect by registering this number over SMS
   --pair            connect by linking to an existing account (8-digit code)
-  --method          sms | voice | wa_old | email  (default: sms)
+  --method          sms | voice | wa_old | flash | email  (default: sms)
+                    flash: WhatsApp rings the number and hangs up; the code is
+                    the last 6 digits of the calling number (Android only)
   --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
@@ -2920,8 +2941,7 @@ async function main() {
         saveStore(store, sessFile);
         out('  status  ' + (r && r.status));
         if (r && (r.status === 'sent' || r.status === 'ok')) {
-          out('  important: enter the code within 10 minutes');
-          out('  run: wa registration --register ' + ph + ' --code <code>');
+          printCodeNextSteps(store, ph, 'wa registration --register ' + ph + ' --code');
         }
       } catch (e) {
         out('  ' + (e.message || String(e)));

package/lib/Client.js

@@ -2327,6 +2327,56 @@ class WhalibmobClient extends EventEmitter {
     return out;
   }
 
+  // Every address a group participant might be filed under.
+  //
+  // Deliberately not _signalJidCandidates: that one starts from the stanza's
+  // `from`, which in a group is the group itself and is not a Signal address at
+  // all. Here the sender is the only subject, under both of the names the same
+  // person answers to.
+  _senderAddressCandidates(senderJid, senderPn) {
+    const out = [];
+    const add = (jid) => {
+      if (!jid) return;
+      const str = String(jid);
+      if (str && !out.includes(str)) out.push(str);
+    };
+    add(senderJid);
+    add(this._counterpartJid(senderJid));
+    add(senderPn);
+    add(this._counterpartJid(senderPn));
+    return out;
+  }
+
+  // The sender key for a group message, under whichever name it was filed.
+  //
+  // A SenderKeyName keeps the user and the device and drops the domain, so the
+  // LID form and the phone form of one person are two different names for one
+  // key. Which of them a message arrives under is the server's choice and it
+  // varies, so a key stored under the name one stanza used is invisible to the
+  // next stanza that names the other. That is the whole of "No session found to
+  // decrypt message" on a group we have only just joined.
+  async _senderKeyDecryptWithCandidates(groupJid, candidates, cipherBuf, id) {
+    let firstErr = null;
+    for (let i = 0; i < candidates.length; i++) {
+      try {
+        const plaintext = await this._signal.senderKeyDecrypt(groupJid, candidates[i], cipherBuf);
+        if (i > 0) {
+          _whaDbg('[DBG] GROUP_DECRYPT id=' + id + ' recovered under ' + candidates[i] +
+            ' after ' + candidates[0] + ' held no sender key');
+        }
+        return plaintext;
+      } catch (err) {
+        if (!firstErr) firstErr = err;
+        // Only "we hold nothing under this name" is worth asking another name
+        // about. A record that exists and refuses the message is a different
+        // problem, and the answer to that is a retry receipt, not another
+        // lookup.
+        if (!/no session found|no senderkeyrecord/i.test(String(err && err.message))) break;
+      }
+    }
+    throw firstErr || new Error('senderKeyDecrypt: no address to try');
+  }
+
   // Try each address in turn and return the first plaintext.
   //
   // A failed attempt leaves nothing behind — libsignal either returns the
@@ -2458,8 +2508,13 @@ class WhalibmobClient extends EventEmitter {
       ? skmsgNode.content
       : Buffer.from(skmsgNode.content || '');
 
+    const senderCandidates = this._senderAddressCandidates(participant);
+    _whaDbg('[DBG] GROUP_DECRYPT id=' + id + ' group=' + from + ' sender=' + participant +
+      (senderCandidates.length > 1 ? ' alts=' + senderCandidates.slice(1).join(',') : '') +
+      ' cipherLen=' + cipherBuf.length);
+
     // Returned for the same reason as the direct-message path above.
-    return this._signal.senderKeyDecrypt(from, participant, cipherBuf)
+    return this._senderKeyDecryptWithCandidates(from, senderCandidates, cipherBuf, id)
       .then(plaintext => {
         this._resolveRetry(id);
         const decoded = this._decodeMsg(plaintext);
@@ -2525,19 +2580,43 @@ class WhalibmobClient extends EventEmitter {
       const encType   = enc.attrs && enc.attrs.type;
       const cipherBuf = Buffer.isBuffer(enc.content) ? enc.content : Buffer.from(enc.content || '');
 
+      // The sender key rides inside a 1-to-1 message, so opening it needs the
+      // session with that participant — and the session may be filed under the
+      // other name they answer to. Addressing only the name this stanza used is
+      // how joining a group ended with every message failing: the distribution
+      // could not be opened, so no sender key was ever stored, so every skmsg
+      // after it had nothing to decrypt with.
+      const senderCandidates = this._senderAddressCandidates(senderJid);
+
       tasks.push(
-        this._signal.decrypt(senderJid, encType, cipherBuf)
+        this._decryptWithCandidates(senderCandidates, encType, cipherBuf, 'skdm')
           .then(async decrypted => {
             const decoded = this._decodeMsg(decrypted);
+            // Filed under the name this stanza used, which is the name the
+            // group message that follows will look it up under.
             if (decoded && decoded.type === 'senderKeyDistribution' &&
                 decoded.groupId && decoded.axolotlBytes) {
               await this._signal.processSKDM(decoded.groupId, senderJid, decoded.axolotlBytes);
+              _whaDbg('[DBG] SKDM_DIST_STORED group=' + decoded.groupId + ' sender=' + senderJid);
             } else if (decoded && decoded.skdm &&
                        decoded.skdm.groupId && decoded.skdm.axolotlBytes) {
               await this._signal.processSKDM(decoded.skdm.groupId, senderJid, decoded.skdm.axolotlBytes);
+              _whaDbg('[DBG] SKDM_DIST_STORED group=' + decoded.skdm.groupId + ' sender=' + senderJid);
+            } else {
+              _whaDbg('[DBG] SKDM_DIST_NONE sender=' + senderJid +
+                ' — the <to> entry for us carried no distribution');
             }
           })
-          .catch(() => {})
+          // Said out loud rather than swallowed. This failing is the reason the
+          // group messages that follow cannot be read, and it used to leave no
+          // trace at all — only the downstream failures were visible, which
+          // pointed at the wrong thing.
+          .catch(err => {
+            _whaDbg('[DBG] SKDM_DIST_ERR sender=' + senderJid +
+              ' tried=[' + senderCandidates.join(',') + ']' +
+              ' err=' + (err && err.message));
+            this.emit('skdm_error', { group: groupJid, sender: senderJid, err });
+          })
       );
     }
 

package/lib/Registration.js

@@ -1154,6 +1154,12 @@ function buildClientMetrics(attempt) {
 
 function getRequestVerificationCodeParameters(store, method, meta, device, attempt) {
   if (device && device.os === 'android') {
+    // Flash call is the one method whose delivery the server only routes when
+    // the client says it can observe an incoming call. The three fields below
+    // are that statement, and asking for `flash` while any of them still says
+    // otherwise gets the request answered with an SMS — or with no route at
+    // all. They stay at their headless-safe values for every other method.
+    const wantsFlash = method === 'flash';
     return [
       'method',                     method,
       'sim_mcc',                    meta.mcc,
@@ -1166,7 +1172,7 @@ function getRequestVerificationCodeParameters(store, method, meta, device, attem
       'sim_type',                   '1',
       'recaptcha',                  '%7B%22stage%22%3A%22ABPROP_DISABLED%22%7D',
       'network_radio_type',         '1',
-      'prefer_sms_over_flash',      'true',
+      'prefer_sms_over_flash',      wantsFlash ? 'false' : 'true',
       'simnum',                     '0',
       'airplane_mode_type',         '0',
       'client_metrics',             buildClientMetrics(attempt),
@@ -1180,8 +1186,8 @@ function getRequestVerificationCodeParameters(store, method, meta, device, attem
       'cellular_strength',          '5',
       'backup_token',               store.backupToken ? toUrlHex(store.backupToken) : '',
       'tos_version',                '5',
-      'call_log_permission',        'false',
-      'manage_call_permission',     'false',
+      'call_log_permission',        wantsFlash ? 'true' : 'false',
+      'manage_call_permission',     wantsFlash ? 'true' : 'false',
       'clicked_education_link',     'false',
       'aid',                        '',
       // Omitted unless a push client supplies a real code — an empty value is
@@ -1545,6 +1551,54 @@ function normalizeCodeResult(code) {
   return String(code == null ? '' : code).replace(/[\s\-]/g, '').replace(/\D/g, '');
 }
 
+// A flash call carries no code of its own: WhatsApp rings the number from a
+// one-time caller ID and drops the call, and the verification code IS that
+// number — its trailing digits. The official Android app reads them out of the
+// call log, which is a thing no server-side client has; here the person holding
+// the handset reads the missed call instead and types what they see.
+//
+// So whatever arrives has to be reduced to those digits. Someone reading a
+// missed call types it however their phone showed it — "+40 21 555 123456",
+// "0040...", or already just the last six — and all three have to land on the
+// same code. Digits are taken first, then the tail: a full number is longer
+// than the code, and its END is the part the server compares.
+//
+// Six is what the decompiled app defaults to. Flash-call providers vary between
+// four and six, so it is overridable rather than baked in, for the number whose
+// server wants a different length.
+const FLASH_CODE_LENGTH = 6;
+
+function flashCodeLength() {
+  const raw = parseInt(process.env.WA_FLASH_CODE_LEN, 10);
+  return raw > 0 ? raw : FLASH_CODE_LENGTH;
+}
+
+function flashCodeFromCallerId(input, len) {
+  const digits = normalizeCodeResult(input);
+  const want   = len > 0 ? len : flashCodeLength();
+  // Shorter than the code means the caller already typed just the tail (or the
+  // handset showed a short number); there is nothing to trim and guessing would
+  // only corrupt it.
+  return digits.length > want ? digits.slice(-want) : digits;
+}
+
+// The digits /register is given, for whichever method the pending code came by.
+// Split out so the choice can be tested on its own: it is the whole difference
+// between confirming a flash call and confirming anything else, and it runs at
+// a point in verifyCode that a test cannot otherwise reach without a network.
+//
+// The method is read off the session because the request and the confirmation
+// are usually two separate commands; opts.method overrides it for a caller that
+// knows better, or for a session saved before the field existed.
+function codeForSubmission(store, code, opts) {
+  const pending = String(
+    (opts && opts.method) || (store && store.codeMethod) || ''
+  ).toLowerCase();
+  return pending === 'flash'
+    ? flashCodeFromCallerId(code)
+    : normalizeCodeResult(code);
+}
+
 // Take the digits the server filed the account under. Brazilian mobiles are the
 // standing example: they gained a ninth digit WhatsApp never adopted, and a
 // session saved under the typed number sends a username on every connection
@@ -1831,6 +1885,20 @@ async function requestSmsCode(store, method, opts) {
     throw new Error('requestSmsCode: email method requires opts.email address');
   }
 
+  // Flash exists on Android and nowhere else. iOS has no public way to read an
+  // incoming call's number, so the platform never offers the method and asking
+  // for it as iOS is answered with an ordinary SMS at best. Refusing here costs
+  // nothing; letting it through spends one of the number's attempts to learn
+  // the same thing from the server.
+  if (method === 'flash' && !(_device && _device.os === 'android')) {
+    throw new Error(
+      'Flash call verification is Android-only — iOS has no API for reading an ' +
+      'incoming call\'s number, so WhatsApp does not offer it there.\n' +
+      '  Re-run as Android:  WA_OS=android wa registration --request-code ' +
+      store.phoneNumber + ' --method flash'
+    );
+  }
+
   // Auto-fallback: if the primary method gets no_routes, try the alternate once.
   // sms → wa_old, wa_old → sms, voice → sms. Never for email: falling back
   // would send an SMS to somebody who asked for an email.
@@ -1867,6 +1935,13 @@ async function requestSmsCode(store, method, opts) {
 
       const status = result.status;
       if (status === 'ok' || status === 'sent') {
+        // Which method actually went through, not which one was asked for: a
+        // flash request that fell back to SMS leaves a code in an SMS, and
+        // confirming it as flash would take the last six digits of a six-digit
+        // code — right by accident here, wrong the moment the lengths differ.
+        // The confirmation step is usually a separate command, so this is
+        // written to the session rather than kept in memory.
+        store.codeMethod = m;
         await sendFunnelLog(store, waVersion, verifyScreen, 'request_code', 'request_code_success');
         return result;
       }
@@ -1935,7 +2010,9 @@ async function requestSmsCode(store, method, opts) {
       `code (tried: ${tried}).\n` +
       `  • Most often the IP: datacenter, VPS and VPN addresses are refused. ` +
       `Use a residential connection, or SOCKS_PROXY=socks5://…\n` +
-      `  • Try another method: --method voice\n` +
+      `  • Try another method: --method voice, or --method flash ` +
+      `(WA_OS=android — rings the number and hangs up; the code is the ` +
+      `last 6 digits of the calling number)\n` +
       `  • Try the other platform: WA_OS=ios (routes differ per platform)\n` +
       `  • wa_old only works if the number is already active on WhatsApp\n` +
       `  • Real SIM numbers fare better than virtual or VoIP ones\n` +
@@ -1959,7 +2036,23 @@ async function verifyCode(store, code, opts) {
   store.device  = _device;
   // A verification code is all digits, so callers reasonably hand one over as a
   // number; coercing here keeps that from dying on .replace before we ask.
-  const normalized = normalizeCodeResult(code);
+  //
+  // Flash is the exception: nothing was ever sent to this number, so what the
+  // caller has is the missed call's own number and the code is its tail. Which
+  // method is pending is remembered from the code request — the two steps are
+  // usually separate commands, so it is read back off the session rather than
+  // assumed to still be in memory. opts.method lets a caller state it outright
+  // for a session that predates the field.
+  const pendingMethod = String(opts.method || store.codeMethod || '').toLowerCase();
+  const normalized    = codeForSubmission(store, code, opts);
+
+  if (pendingMethod === 'flash') {
+    const typed = normalizeCodeResult(code);
+    if (typed.length !== normalized.length) {
+      _whaDbg('[DBG] REG flash caller-id ' + typed.length + ' digits → code ' +
+        normalized + ' (last ' + normalized.length + ')');
+    }
+  }
 
   const screen = currentVerifyScreen(store);
   await sendFunnelLog(store, waVersion, screen, 'submit_code', 'submit_code_attempt');
@@ -2055,5 +2148,7 @@ module.exports._token = { computeToken, androidMaterialPath, registrationHeaders
 // Challenge / two-factor internals, exposed for tests. Not part of the public API.
 module.exports._verify = {
   hasChallenge, is2FARequired, decodeOrNull, isSuccessful,
-  normalizeCodeResult, currentVerifyScreen, adoptCanonicalNumber, funnelEnabled, waitHint
+  normalizeCodeResult, currentVerifyScreen, adoptCanonicalNumber, funnelEnabled, waitHint,
+  flashCodeFromCallerId, flashCodeLength, codeForSubmission,
+  getRequestVerificationCodeParameters
 };

package/lib/Store.js

@@ -195,6 +195,12 @@ function storeToJson(store) {
     backupToken:    store.backupToken ? store.backupToken.toString('base64') : null,
     registered:     !!store.registered,
     codePending:    store.codePending || false,
+    // Which delivery method the pending code actually went out by. The two
+    // registration steps are normally separate commands, so the confirmation
+    // has no memory of the request unless it is written down — and for a flash
+    // call it has to know, since that code is read off the caller ID rather
+    // than out of a message.
+    codeMethod:     store.codeMethod || null,
     name,
     version,
     device,
@@ -237,6 +243,7 @@ function storeFromJson(obj) {
     backupToken:    obj.backupToken ? Buffer.from(obj.backupToken, 'base64') : crypto.randomBytes(20),
     registered:     !!obj.registered,
     codePending:    obj.codePending || false,
+    codeMethod:     obj.codeMethod || null,
     name,
     version,
     device,

package/lib/signal/SenderKey.js

@@ -95,6 +95,15 @@ class SenderKeyStore {
     this._dirty     = false;
     this._rev       = 0;
     this._saveTimer = null;
+    // Same three as in SignalStore, for the same reason. The debounced write
+    // here was never cancelled or awaited either, so a synchronous flush could
+    // be overtaken by an older one still in flight — and this file is where the
+    // group sender keys live, including the record of who has already been sent
+    // ours. _writtenRev is what the file holds; _writing keeps the async writes
+    // to one at a time; _writeAgain remembers one that came due mid-write.
+    this._writtenRev = 0;
+    this._writing    = false;
+    this._writeAgain = false;
 
     // Detachable, for the same reason as in SignalStore: a replaced store must
     // not keep three process listeners alive for the rest of the run.
@@ -115,7 +124,14 @@ class SenderKeyStore {
       process.removeListener('SIGTERM', this._onSigTerm);
       process.removeListener('SIGINT',  this._onSigInt);
     } catch (_) {}
-    this._filePath = null;
+    // Clearing the path also tells a write still in flight to stand down — it
+    // checks the path it started with before renaming. The caller detaches in
+    // order to move these files, so leave nothing of ours in the directory it
+    // is about to rename.
+    const stale = this._filePath ? [this._tmpPath(true), this._tmpPath(false)] : [];
+    this._filePath   = null;
+    this._writeAgain = false;
+    for (const f of stale) { try { fs.unlinkSync(f); } catch (_) {} }
   }
 
   attachFile(filePath) {
@@ -150,14 +166,52 @@ class SenderKeyStore {
     }
   }
 
+  // Everything that is persisted, as it goes on disk.
+  _snapshot() {
+    return JSON.stringify(this._data, null, 2);
+  }
+
+  // Where a write assembles the file before it becomes the file. The sync and
+  // async writers get separate names so neither can find the other's
+  // half-written temp file under it.
+  _tmpPath(sync) {
+    return this._filePath + (sync ? '.stmp' : '.atmp');
+  }
+
+  // A rename replaces the file, so the one that lands carries the temp file's
+  // permissions and not the old file's. This holds group signing keys, and an
+  // operator who tightened its mode would find it loosened again by the next
+  // write — so carry across whatever the file already had.
+  _modeOf(file) {
+    try { return fs.statSync(file).mode & 0o777; } catch (_) { return null; }
+  }
+
   _flushSync() {
     if (!this._dirty || !this._filePath) return;
     if (this._saveTimer) { clearTimeout(this._saveTimer); this._saveTimer = null; }
+    const rev  = this._rev;
+    const file = this._filePath;
+    const tmp  = this._tmpPath(true);
     try {
-      fs.mkdirSync(path.dirname(this._filePath), { recursive: true });
-      fs.writeFileSync(this._filePath, JSON.stringify(this._data, null, 2));
-      this._dirty = false;
-    } catch (_) {}
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      const mode = this._modeOf(file);
+      fs.writeFileSync(tmp, this._snapshot(), mode !== null
+        ? { encoding: 'utf8', mode } : 'utf8');
+      if (mode !== null) fs.chmodSync(tmp, mode);
+      fs.renameSync(tmp, file);
+      // Take the async writer's temp file away from it. Its "have I been
+      // overtaken?" check runs on this thread, but the rename it authorises is
+      // carried out on a pool thread afterwards — and at exit the pool is
+      // usually busy, so that rename can still be queued now and execute during
+      // teardown, putting this snapshot back to an older one. Its callback
+      // never runs there, so nothing would notice. Removing the source makes
+      // that queued rename fail ENOENT instead.
+      try { fs.unlinkSync(this._tmpPath(false)); } catch (_) {}
+      this._writtenRev = rev;
+      this._dirty      = false;
+    } catch (_) {
+      try { fs.unlinkSync(tmp); } catch (_) {}
+    }
   }
 
   _save() {
@@ -167,18 +221,65 @@ class SenderKeyStore {
     if (this._saveTimer) clearTimeout(this._saveTimer);
     this._saveTimer = setTimeout(() => {
       this._saveTimer = null;
-      // The revision this write is a snapshot of.
-      const rev  = this._rev;
-      const data = JSON.stringify(this._data, null, 2);
-      fs.mkdirSync(path.dirname(this._filePath), { recursive: true });
-      // Only clear the flag when nothing changed while the write was running.
-      // A mutation that arrived after the snapshot is not in `data`, and its
-      // own debounce timer may never fire — clearing here would make the
-      // exit-time _flushSync() skip it and lose it.
-      fs.writeFile(this._filePath, data, 'utf8', () => {
+      this._writeAsync();
+    }, _SK_DEBOUNCE_MS);
+  }
+
+  // The debounced write itself: temp file, then rename into place, and only if
+  // nothing newer reached the disk in the meantime.
+  _writeAsync() {
+    if (!this._filePath || !this._dirty) return;
+    // Fold a write that comes due mid-write into the one already running rather
+    // than starting a second one over the same temp file.
+    if (this._writing) { this._writeAgain = true; return; }
+
+    // Read once, here: by the time the callbacks run either may have moved on,
+    // and that is exactly what they have to notice.
+    const rev  = this._rev;
+    const file = this._filePath;
+    const tmp  = this._tmpPath(false);
+
+    let data, mode;
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      mode = this._modeOf(file);
+      data = this._snapshot();
+    } catch (_) { return; }
+
+    this._writing    = true;
+    this._writeAgain = false;
+
+    const finish = () => {
+      this._writing = false;
+      // A write came due while this one was running and was folded into it.
+      // Every other mutation armed its own debounce timer, which is still
+      // pending and will write what is current.
+      if (this._writeAgain && this._dirty && this._filePath) this._writeAsync();
+    };
+    const abandon = () => { fs.unlink(tmp, () => {}); finish(); };
+
+    // Created already tight rather than widening the window in which a file of
+    // signing keys sits at the umask default.
+    fs.writeFile(tmp, data, mode !== null ? { encoding: 'utf8', mode } : 'utf8', (err) => {
+      if (err) return abandon();
+      // detach() let the file go, or a synchronous flush wrote newer state
+      // while this one was running. Renaming now would put an older snapshot
+      // back and take every sender key written since with it.
+      if (file !== this._filePath || rev <= this._writtenRev) return abandon();
+      if (mode !== null) { try { fs.chmodSync(tmp, mode); } catch (_) {} }
+      fs.rename(tmp, file, (renameErr) => {
+        if (renameErr) return abandon();
+        // Never walk it backwards: a synchronous flush can land — and record a
+        // higher revision — between the check above and this callback.
+        if (rev > this._writtenRev) this._writtenRev = rev;
+        // Only clear the flag when nothing changed while the write was running.
+        // A mutation that arrived after the snapshot is not in `data`, and
+        // clearing here would make the exit-time _flushSync() skip it and lose
+        // it.
         if (this._rev === rev) this._dirty = false;
+        finish();
       });
-    }, _SK_DEBOUNCE_MS);
+    });
   }
 
   _key(groupId, senderId) {

package/package.json

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