whalibmob 5.14.4 → 5.14.5

package/cli.js

@@ -202,7 +202,12 @@ function enableWireTrace() {
         return origWrite(chunk, ...rest);
       };
 
-      sock.on('data', (d) => {
+      // Prepended, not appended: the socket already carries the handshake's own
+      // data listener, registered while connect() was building the socket. An
+      // appended one runs after the frame has been read, so a frame the server
+      // sent would print *after* the error it caused — or not at all, once the
+      // failure tears the connection down. The trace has to come first.
+      sock.prependListener('data', (d) => {
         if (this.secured) return;
         // Label positionally, but say so when the reply is plainly not a Noise
         // frame — a proxy or captive portal answering in ASCII is worth reading

package/lib/noise.js

@@ -301,6 +301,25 @@ function readFrameLength(data) {
   return (data[0] << 16) | (data[1] << 8) | data[2];
 }
 
+// ─── Handshake trace ─────────────────────────────────────────────────────────
+//
+// The handshake runs before there are stanzas to log, so without this the debug
+// output jumps from "connecting" to either a secured channel or an error with
+// nothing in between — and when it fails, nothing to say which step it got to.
+//
+// Only public material is rendered: ephemeral and static public keys, frame and
+// field sizes, certificate outcome. Derived session keys and anything private
+// are named but never printed, because a debug trace is the thing people paste
+// into a bug report.
+function _hsKey(buf) {
+  if (!Buffer.isBuffer(buf)) return String(buf);
+  return buf.toString('hex') + ' (' + buf.length + 'B)';
+}
+
+function _hsSize(buf) {
+  return Buffer.isBuffer(buf) ? buf.length + 'B' : 'absent';
+}
+
 // ─── NoiseSocket ─────────────────────────────────────────────────────────────
 //
 // Events emitted:
@@ -395,9 +414,18 @@ class NoiseSocket extends EventEmitter {
     };
     this.noiseState.hash(this._ephemeralKeyPair.public);
 
+    _whaDbg('[DBG] NOISE handshake begin  transport=' + this.transport +
+      '  prologue=' + this._prologue.toString('hex') +
+      '  pattern=Noise_XX_25519_AESGCM_SHA256');
+    _whaDbg('[DBG] NOISE ──▶ ClientHello  ephemeral=' + _hsKey(this._ephemeralKeyPair.public));
+
     const helloPayload = encodeHandshakeClientHello(this._ephemeralKeyPair.public);
     const frame        = Buffer.concat([this._prologue, makeFrame(helloPayload)]);
+    _whaDbg('[DBG] NOISE ──▶ ClientHello  ' + frame.length + 'B on the wire = prologue ' +
+      this._prologue.length + 'B + header ' + FRAME_HEADER_SIZE + 'B + payload ' +
+      helloPayload.length + 'B');
     this.socket.write(frame);
+    _whaDbg('[DBG] NOISE     waiting for ServerHello');
   }
 
   _onData(data) {
@@ -424,16 +452,24 @@ class NoiseSocket extends EventEmitter {
 
   _handleHandshakeFrame(frame) {
     try {
+      _whaDbg('[DBG] NOISE ◀── ServerHello  ' + frame.length + 'B frame');
       const serverHello = decodeServerHello(frame);
+      _whaDbg('[DBG] NOISE ◀── ServerHello  ephemeral=' + _hsSize(serverHello.ephemeral) +
+        '  static=' + _hsSize(serverHello.staticEnc) + ' encrypted' +
+        '  certificate=' + _hsSize(serverHello.payload) + ' encrypted');
       if (!serverHello.ephemeral) throw new Error('No server ephemeral in ServerHello');
+      _whaDbg('[DBG] NOISE ◀── server ephemeral=' + _hsKey(serverHello.ephemeral));
 
       this.noiseState.hash(serverHello.ephemeral);
       const sharedEE  = dhShared(this._ephemeralKeyPair.private, serverHello.ephemeral);
       this.noiseState.mixKey(sharedEE);
+      _whaDbg('[DBG] NOISE     mixed DH(our ephemeral, server ephemeral)');
 
       const serverStaticDec = this.noiseState.decryptWithAd(serverHello.staticEnc);
+      _whaDbg('[DBG] NOISE ◀── server static key decrypted=' + _hsKey(serverStaticDec));
       const sharedSE        = dhShared(this._ephemeralKeyPair.private, serverStaticDec);
       this.noiseState.mixKey(sharedSE);
+      _whaDbg('[DBG] NOISE     mixed DH(our ephemeral, server static)');
 
       // The server is authenticated here, before ClientFinish hands it our
       // static key and payload. A ServerHello without a certificate leaves
@@ -442,14 +478,20 @@ class NoiseSocket extends EventEmitter {
         throw new Error('WA server cert validation failed: the server sent no certificate');
       }
       const certPlain = this.noiseState.decryptWithAd(serverHello.payload);
+      _whaDbg('[DBG] NOISE ◀── certificate decrypted=' + certPlain.length + 'B — verifying');
       validateServerCert(certPlain, serverStaticDec);
+      _whaDbg('[DBG] NOISE ◀── certificate verified: signed by the root CA and ' +
+        'certifying the static key above — server authenticated');
 
       const noisePriv  = this.store.noiseKeyPair.private;
       // Send the raw 32-byte noise public key (no 0x05 Signal prefix)
       const noisePub   = stripKeyPrefix(this.store.noiseKeyPair.public);
       const encStatic  = this.noiseState.encryptWithAd(noisePub);
+      _whaDbg('[DBG] NOISE ──▶ our static key=' + _hsKey(noisePub) +
+        ' encrypted to ' + encStatic.length + 'B');
       const sharedSS   = dhShared(noisePriv, serverHello.ephemeral);
       this.noiseState.mixKey(sharedSS);
+      _whaDbg('[DBG] NOISE     mixed DH(our static, server ephemeral)');
 
       // Web mode hands us a finished companion payload; there is no phone
       // identity to derive anything from, and the fields below do not exist on
@@ -457,6 +499,9 @@ class NoiseSocket extends EventEmitter {
       if (this._buildPayload) {
         const encPayload = this.noiseState.encryptWithAd(this._buildPayload());
         const finish     = encodeHandshakeClientFinish(encStatic, encPayload);
+        _whaDbg('[DBG] NOISE ──▶ ClientFinish  static=' + encStatic.length + 'B  payload=' +
+          encPayload.length + 'B (companion)  ' + (finish.length + FRAME_HEADER_SIZE) +
+          'B on the wire');
         this.socket.write(makeFrame(finish));
 
         const webKeys     = this.noiseState.split();
@@ -465,6 +510,7 @@ class NoiseSocket extends EventEmitter {
         this.writeCounter = 0;
         this.readCounter  = 0;
         this.secured      = true;
+        _whaDbg('[DBG] NOISE     split() derived the send and receive keys — channel secured');
 
         if (this._expectSuccess) {
           this._awaitingAuth = true;
@@ -560,6 +606,9 @@ class NoiseSocket extends EventEmitter {
 
       const encPayload = this.noiseState.encryptWithAd(payload);
       const finish     = encodeHandshakeClientFinish(encStatic, encPayload);
+      _whaDbg('[DBG] NOISE ──▶ ClientFinish  static=' + encStatic.length + 'B  payload=' +
+        encPayload.length + 'B (username=' + this.store.phoneNumber + ' version=' +
+        _version + ')  ' + (finish.length + FRAME_HEADER_SIZE) + 'B on the wire');
       this.socket.write(makeFrame(finish));
 
       const keys        = this.noiseState.split();
@@ -567,6 +616,8 @@ class NoiseSocket extends EventEmitter {
       this.readKey      = keys.readKey;
       this.writeCounter = 0;
       this.readCounter  = 0;
+      _whaDbg('[DBG] NOISE     split() derived the send and receive keys — channel secured');
+      _whaDbg('[DBG] NOISE     waiting for the server to accept the payload');
       this.secured      = true;
 
       // Wait for the server's <success> or <failure> confirmation before
@@ -575,6 +626,8 @@ class NoiseSocket extends EventEmitter {
       this._awaitingAuth = true;
 
     } catch (err) {
+      // The step that failed is the one after the last line traced above.
+      _whaDbg('[DBG] NOISE ✗ handshake failed: ' + (err && err.message));
       if (this._connectReject) {
         this._connectReject(err);
         this._connectResolve = null;
@@ -596,6 +649,8 @@ class NoiseSocket extends EventEmitter {
       if (this._awaitingAuth) {
         this._awaitingAuth = false;
         const tag = node && node.description;
+        _whaDbg('[DBG] NOISE ◀── <' + tag + '> — the first frame over the secured channel, ' +
+          'and the server\'s answer on the payload');
 
         if (tag === 'success') {
           if (this._connectResolve) {

package/package.json

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