whalibmob 5.33.0 → 5.33.1

package/README.md

@@ -2819,9 +2819,9 @@ Apple's flow is not Google's, but it lands in the same place:
 | 2 | `init-p01st.push.apple.com/bag` | which courier hosts to dial |
 | 3 | `<n>-courier.push.apple.com:443` | the device token, then `GET_TOKEN` for `net.whatsapp.WhatsApp` — the per-topic token that *is* `push_token` |
 
-Step 1 runs once per number and its result is cached on the session: the certificate is good for about three years, and the identity behind it is what makes the same push token come back on the next run. A token WhatsApp has already recorded stops being deliverable if that identity is thrown away, which is the same reason the Firebase android id is kept.
+Step 1 runs once per number and its result is cached on the session: the certificate Apple issues is good for a year, and the identity behind it is what makes the same push token come back on the next run. A token WhatsApp has already recorded stops being deliverable if that identity is thrown away, which is the same reason the Firebase android id is kept.
 
-The courier connection is a TLS stream with ALPN `apns-security-v3` — the device proves itself with a signature over a fresh nonce in the first frame rather than with a TLS client certificate. A network that terminates TLS in the middle cannot carry it, and the failure says so by name instead of looking like a dropped connection.
+The courier connection is a TLS stream that offers ALPN `apns-security-v3` — the device proves itself with a signature over a fresh nonce in the first frame rather than with a TLS client certificate. Apple accepts the offer without echoing it back, so a missing echo is normal and is not treated as a failure. A network that terminates TLS in the middle cannot carry the stream; what gives it away is the certificate, since a middlebox has to present one its own CA signed rather than Apple's. The failure names that issuer, instead of looking like a dropped connection.
 
 Turn it off with `WA_APNS_PUSH=0`.
 

package/lib/apns-courier.js

@@ -215,17 +215,22 @@ function parseBag(body) {
 /**
  * Where to ask for the bag, in the order to try.
  *
- * HTTPS first because that is the one a proxied session can route: the SOCKS
- * agent is an https.Agent, so a plain-HTTP attempt would go out direct and
- * around the proxy the user asked for. When one is configured the fallback is
- * dropped rather than leaked — the default pool is the better answer.
+ * Plain HTTP is the canonical URL and the one that actually answers: the bag is
+ * signed rather than encrypted, and the host does not serve a certificate for
+ * its own name — it presents one for images.apple.com, so HTTPS fails the
+ * hostname check every time. It is tried second only in case that ever changes.
+ *
+ * With a proxy configured the order inverts and HTTP is dropped entirely: the
+ * SOCKS agent is an https.Agent, so a plain-HTTP attempt would go out direct,
+ * around the proxy the user set precisely so that nothing does. Losing the bag
+ * costs nothing — the default pool below is the same answer it would have
+ * given.
  *
  * @returns {string[]}
  */
 function bagUrls() {
-  const urls = ['https://' + BAG_HOST + BAG_PATH];
-  if (!socksProxyUrl()) urls.push('http://' + BAG_HOST + BAG_PATH);
-  return urls;
+  if (socksProxyUrl()) return ['https://' + BAG_HOST + BAG_PATH];
+  return ['http://' + BAG_HOST + BAG_PATH, 'https://' + BAG_HOST + BAG_PATH];
 }
 
 async function fetchBag() {
@@ -278,6 +283,34 @@ function certificateDer(certificate) {
   return new crypto.X509Certificate(certificate).raw;
 }
 
+// A certificate field can repeat, and Node hands a repeated one back as an
+// array, so every read goes through this rather than assuming a string.
+function issuerValues(issuer, field) {
+  if (!issuer || issuer[field] == null) return [];
+  return [].concat(issuer[field]).map(String);
+}
+
+/**
+ * Whether the courier's certificate was issued by Apple.
+ *
+ * A middlebox that terminates TLS has to present its own certificate, signed
+ * by its own CA, because it cannot hold Apple's key. So the issuer's
+ * organisation is the one field that tells the real courier from something
+ * standing in front of it.
+ *
+ * @param {object|null} issuer  the issuer from getPeerCertificate()
+ * @returns {boolean}
+ */
+function isApplePeer(issuer) {
+  return issuerValues(issuer, 'O').includes('Apple Inc.');
+}
+
+/** A readable name for an issuer, for a log line or an error message. */
+function describeIssuer(issuer) {
+  const name = issuerValues(issuer, 'CN')[0] || issuerValues(issuer, 'O')[0];
+  return name ? '"' + name + '"' : 'an unnamed issuer';
+}
+
 // ─── The connection ───────────────────────────────────────────────────────────
 
 class ApnsCourierConnection {
@@ -296,6 +329,10 @@ class ApnsCourierConnection {
     this.onLost = typeof opts.onLost === 'function' ? opts.onLost : null;
 
     this.socket = null;
+    // Who signed the certificate the courier presented, set by the TLS
+    // handshake. Null until a socket exists, so a failure that happens before
+    // one does carries no note about interception.
+    this.peerIssuer = null;
     this.deviceToken = session.deviceToken || null;
     // Set by the handshake when Apple hands back a device token other than the
     // one presented. False until then, including before any connection.
@@ -329,6 +366,15 @@ class ApnsCourierConnection {
       // from. Callers do close on failure, but the connection should not depend
       // on them remembering to.
       this.close();
+      // A failure on a connection whose certificate Apple did not sign is the
+      // signature of TLS being terminated in the middle: the courier never saw
+      // the frame, something else did and hung up. Worth naming, because the
+      // error on its own reads like Apple refused the credentials.
+      if (this.peerIssuer && !isApplePeer(this.peerIssuer)) {
+        err.message += ' (the courier presented a certificate from ' +
+          describeIssuer(this.peerIssuer) + ', not Apple — TLS is being' +
+          ' intercepted on this network)';
+      }
       throw err;
     }
     return this;
@@ -345,14 +391,17 @@ class ApnsCourierConnection {
         host,
         port: COURIER_PORT,
         servername: host,
+        // Offered as every client offers it. Apple accepts it without echoing
+        // it back — see the issuer check below for what that means.
         ALPNProtocols: [COURIER_ALPN],
-        // The courier answers with a certificate from an Apple-internal issuer
-        // that is in no public trust store, so chain validation cannot succeed
-        // here and is not what protects this connection: the device proves
-        // itself with a signature over a fresh nonce, and every push that
-        // matters is a WhatsApp payload the registration server signs for
-        // separately. Verification stays on for every other socket in the
-        // library — this is the one endpoint that cannot use it.
+        // The courier answers with a certificate from Apple Server
+        // Authentication CA, which chains to an Apple root that is not in
+        // Node's bundled trust store, so chain validation cannot succeed here
+        // and is not what protects this connection: the device proves itself
+        // with a signature over a fresh nonce, and every push that matters is
+        // a WhatsApp payload the registration server signs for separately.
+        // Verification stays on for every other socket in the library — this
+        // is the one endpoint that cannot use it.
         rejectUnauthorized: false
       };
       if (base) options.socket = base;
@@ -360,18 +409,17 @@ class ApnsCourierConnection {
       const socket = tls.connect(options, () => {
         socket.setTimeout(0);
         socket.setNoDelay(true);
-        // The courier speaks its own protocol over the TLS session, and says so
-        // through ALPN. A middlebox that terminates TLS — a corporate gateway,
-        // an inspecting proxy — negotiates no protocol at all and then drops
-        // the connection the moment a frame that is not HTTP goes out. Saying
-        // that here turns an unexplained disconnect into the one line that
-        // names the cause.
-        if (socket.alpnProtocol !== COURIER_ALPN) {
-          socket.destroy();
-          reject(new Error('courier did not negotiate ' + COURIER_ALPN +
-            ' (TLS is being intercepted on this network)'));
-          return;
-        }
+        // Who signed the certificate on the other end. This, not ALPN, is what
+        // tells a genuine courier from a middlebox: Apple's courier accepts the
+        // apns-security-v3 offer without echoing it back, so a missing echo is
+        // what the real thing looks like too. A first version refused any
+        // connection that did not echo it, and so refused Apple itself.
+        //
+        // The issuer is recorded, not enforced. The handshake decides; this
+        // only explains a failure afterwards.
+        const certificate = socket.getPeerCertificate() || {};
+        this.peerIssuer = certificate.issuer || null;
+        _whaDbg('[DBG] APNs courier certificate issued by ' + describeIssuer(this.peerIssuer));
         resolve(socket);
       });
       socket.setTimeout(CONNECT_TIMEOUT_MS, () => socket.destroy(new Error('courier connect timed out')));
@@ -617,6 +665,8 @@ module.exports = {
   topicHash,
   createNonce,
   certificateDer,
+  isApplePeer,
+  describeIssuer,
   TAG,
   DEFAULT_BAG,
   F_NOTIFICATION_TOPIC,

package/lib/apns.js

@@ -16,7 +16,7 @@
 //                   we generate, given a FairPlay-signed request. This is what
 //                   a Mac or an iPhone does on first boot, and what every
 //                   desktop iMessage/APNs client has done since. The
-//                   certificate is good for about three years, so it is
+//                   certificate Apple signs is good for a year, so it is
 //                   persisted with the account and the handshake runs once.
 //   2. courier      one TLS connection to Apple carrying the device token, and
 //                   over it GET_TOKEN for net.whatsapp.WhatsApp — the per-topic

package/package.json

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