@mtcute/core 0.30.0 → 0.30.1

package/network/mtproxy/_fake-tls.js

@@ -1,6 +1,7 @@
 import { Bytes, read } from "@fuman/io";
 import { u8, typed, bigint } from "@fuman/utils";
 const MAX_TLS_PACKET_LENGTH = 2878;
+const MAX_TLS_HELLO_SIZE = 4096;
 const KEY_MOD = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDn;
 const QUAD_RES_MOD = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDn;
 const QUAD_RES_POW = 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6n;
@@ -27,7 +28,11 @@ function _isQuadraticResidue(a) {
   return r === 1n;
 }
 function executeTlsOperations(h) {
-  h.string([22, 3, 1, 2, 0, 1, 0, 1, 252, 3, 3]);
+  h.string([22, 3, 1]);
+  h.beginScope();
+  h.string([1, 0]);
+  h.beginScope();
+  h.string([3, 3]);
   h.zero(32);
   h.string([32]);
   h.random(32);
@@ -65,67 +70,34 @@ function executeTlsOperations(h) {
     0,
     53,
     1,
-    0,
-    1,
-    147
+    0
   ]);
-  h.grease(2);
-  h.string([0, 0, 0, 0]);
-  h.beginScope();
   h.beginScope();
-  h.string([0]);
-  h.beginScope();
-  h.domain();
-  h.endScope();
-  h.endScope();
-  h.endScope();
-  h.string([0, 23, 0, 0, 255, 1, 0, 1, 0, 0, 10, 0, 10, 0, 8]);
-  h.grease(4);
-  h.string(
-    [
-      0,
-      29,
-      0,
-      23,
-      0,
-      24,
-      0,
-      11,
-      0,
-      2,
-      1,
-      0,
-      0,
-      35,
-      0,
-      0,
-      0,
-      16,
-      0,
-      14,
-      0,
-      12,
-      2,
-      104,
-      50,
-      8,
-      104,
-      116,
-      116,
-      112,
-      47,
-      49,
-      46,
-      49,
-      0,
-      5,
-      0,
-      5,
-      1,
-      0,
-      0,
-      0,
-      0,
+  h.grease(2);
+  h.string([0, 0]);
+  h.permutation([
+    (w) => {
+      w.string([0, 0]);
+      w.beginScope();
+      w.beginScope();
+      w.string([0]);
+      w.beginScope();
+      w.domain();
+      w.endScope();
+      w.endScope();
+      w.endScope();
+    },
+    (w) => w.string([0, 5, 0, 5, 1, 0, 0, 0, 0]),
+    // status_request
+    (w) => {
+      w.string([0, 10, 0, 12, 0, 10]);
+      w.grease(4);
+      w.string([17, 236, 0, 29, 0, 23, 0, 24]);
+    },
+    (w) => w.string([0, 11, 0, 2, 1, 0]),
+    // ec_point_formats
+    (w) => w.string([
+      // signature_algorithms
       0,
       13,
       0,
@@ -147,27 +119,76 @@ function executeTlsOperations(h) {
       8,
       6,
       6,
-      1,
+      1
+    ]),
+    (w) => w.string([
+      // application_layer_protocol_negotiation (ALPN)
       0,
-      18,
-      0,
-      0,
-      0,
-      51,
+      16,
       0,
-      43,
+      14,
       0,
-      41
-    ]
-  );
-  h.grease(4);
-  h.string([0, 1, 0, 0, 29, 0, 32]);
-  h.key();
-  h.string([0, 45, 0, 2, 1, 1, 0, 43, 0, 11, 10]);
-  h.grease(6);
-  h.string([3, 4, 3, 3, 3, 2, 3, 1, 0, 27, 0, 3, 2, 0, 2]);
+      12,
+      2,
+      104,
+      50,
+      8,
+      104,
+      116,
+      116,
+      112,
+      47,
+      49,
+      46,
+      49
+    ]),
+    (w) => w.string([0, 18, 0, 0]),
+    // signed_certificate_timestamp
+    (w) => w.string([0, 23, 0, 0]),
+    // extended_master_secret
+    (w) => w.string([0, 27, 0, 3, 2, 0, 2]),
+    // compress_certificate
+    (w) => w.string([0, 35, 0, 0]),
+    // session_ticket
+    (w) => {
+      w.string([0, 43, 0, 7, 6]);
+      w.grease(6);
+      w.string([3, 4, 3, 3]);
+    },
+    (w) => w.string([0, 45, 0, 2, 1, 1]),
+    // psk_key_exchange_modes
+    (w) => {
+      w.string([0, 51, 4, 239, 4, 237]);
+      w.grease(4);
+      w.string([0, 1, 0, 17, 236, 4, 192]);
+      w.mlKem768Key();
+      w.key();
+      w.string([0, 29, 0, 32]);
+      w.key();
+    },
+    (w) => w.string([68, 205, 0, 5, 0, 3, 2, 104, 50]),
+    // application_settings (ALPS)
+    (w) => {
+      w.string([254, 13]);
+      w.beginScope();
+      w.string([0, 0, 1, 0, 1]);
+      w.random(1);
+      w.string([0, 32]);
+      w.random(32);
+      w.beginScope();
+      w.echPayload();
+      w.endScope();
+      w.endScope();
+    },
+    (w) => w.string([255, 1, 0, 1, 0])
+    // renegotiation_info
+  ]);
   h.grease(3);
-  h.string([0, 1, 0, 0, 21]);
+  h.string([0, 1, 0]);
+  h.padding();
+  h.endScope();
+  h.endScope();
+  h.endScope();
 }
 function initGrease(crypto, size) {
   const buf = crypto.randomBytes(size);
@@ -182,12 +203,12 @@ function initGrease(crypto, size) {
   return buf;
 }
 class TlsHelloWriter {
-  constructor(crypto, size, domain) {
+  constructor(crypto, domain, grease) {
     this.crypto = crypto;
     this._domain = domain;
-    this.buf = u8.alloc(size);
+    this.buf = u8.alloc(MAX_TLS_HELLO_SIZE);
     this.dv = typed.toDataView(this.buf);
-    this._grease = initGrease(this.crypto, 7);
+    this._grease = grease ?? initGrease(this.crypto, 7);
   }
   buf;
   dv;
@@ -228,6 +249,24 @@ class TlsHelloWriter {
       }
     }
   }
+  // fake X25519MLKEM768 hybrid keyshare's ml-kem-768 part: 384 coefficients
+  // (mod 3329) packed 3 bytes per 2 coefficients, followed by 32 random bytes
+  mlKem768Key() {
+    const rnd = this.crypto.randomBytes(384 * 8);
+    const dv = typed.toDataView(rnd);
+    for (let i = 0; i < 384; i++) {
+      const a = dv.getUint32(i * 8, true) % 3329;
+      const b = dv.getUint32(i * 8 + 4, true) % 3329;
+      this.buf[this.pos++] = a & 255;
+      this.buf[this.pos++] = (a >> 8) + ((b & 15) << 4);
+      this.buf[this.pos++] = b >> 4;
+    }
+    this.random(32);
+  }
+  // GREASE ECH payload: random bytes of length 144/176/208/240
+  echPayload() {
+    this.random(this._randomInt(4) * 32 + 144);
+  }
   beginScope() {
     this._scopes.push(this.pos);
     this.pos += 2;
@@ -237,29 +276,55 @@ class TlsHelloWriter {
     if (begin === void 0) {
       throw new Error("endScope called without beginScope");
     }
-    const end = this.pos;
-    const size = end - begin - 2;
-    this.dv.setUint16(begin, size);
+    this.dv.setUint16(begin, this.pos - begin - 2);
   }
-  async finish(secret) {
-    const padSize = 515 - this.pos;
-    const unixTime = ~~(Date.now() / 1e3);
+  // render each part into its own buffer, then emit them in random order —
+  // mimics chrome's per-connection tls extension shuffling
+  permutation(parts) {
+    const rendered = parts.map((fn) => {
+      const sub = new TlsHelloWriter(this.crypto, this._domain, this._grease);
+      fn(sub);
+      return sub.buf.subarray(0, sub.pos);
+    });
+    for (let i = rendered.length - 1; i > 0; i--) {
+      const j = this._randomInt(i + 1);
+      const tmp = rendered[i];
+      rendered[i] = rendered[j];
+      rendered[j] = tmp;
+    }
+    for (const part of rendered) {
+      this.string(part);
+    }
+  }
+  // tls padding extension, only emitted for hellos smaller than 513 bytes
+  padding() {
+    if (this.pos >= 513) return;
+    const size = 513 - this.pos;
+    this.string([0, 21]);
     this.beginScope();
-    this.zero(padSize);
+    this.zero(size);
     this.endScope();
-    const hash = await this.crypto.hmacSha256(this.buf, secret);
+  }
+  _randomInt(max) {
+    return typed.toDataView(this.crypto.randomBytes(4)).getUint32(0, true) % max;
+  }
+  async finish(secret) {
+    const data = this.buf.subarray(0, this.pos);
+    const unixTime = ~~(Date.now() / 1e3);
+    const hash = await this.crypto.hmacSha256(data, secret);
     const dv = typed.toDataView(hash);
     const old = dv.getInt32(28, true);
     dv.setInt32(28, old ^ unixTime, true);
-    this.buf.set(hash, 11);
-    return this.buf;
+    data.set(hash, 11);
+    return data;
   }
 }
 async function generateFakeTlsHeader(domain, secret, crypto) {
-  const writer = new TlsHelloWriter(crypto, 517, domain);
+  const writer = new TlsHelloWriter(crypto, domain);
   executeTlsOperations(writer);
   return writer.finish(secret);
 }
+const EMPTY_BYTES = Bytes.from(u8.empty);
 class FakeTlsPacketCodec {
   // protected _stream: Buffer = Buffer.alloc(0)
   constructor(_inner) {
@@ -294,23 +359,20 @@ class FakeTlsPacketCodec {
   }
   async decode(reader, eof) {
     if (eof) return null;
-    if (reader.available < 5) return null;
-    const header = reader.readSync(3);
-    if (header[0] !== 23 || header[1] !== 3 || header[2] !== 3) {
-      throw new Error("Invalid TLS header");
-    }
-    const length = read.uint16be(reader);
-    if (length < reader.available - 5) {
-      reader.rewind(5);
-      return null;
-    }
-    const packet = reader.readSync(length);
-    const inner = await this._inner.decode(Bytes.from(packet), eof);
-    if (!inner) {
-      reader.rewind(5 + length);
-      return null;
+    while (reader.available >= 5) {
+      const header = reader.readSync(3);
+      if (header[0] !== 23 || header[1] !== 3 || header[2] !== 3) {
+        throw new Error("Invalid TLS header");
+      }
+      const length = read.uint16be(reader);
+      if (reader.available < length) {
+        reader.rewind(5);
+        break;
+      }
+      const inner = await this._inner.decode(Bytes.from(reader.readSync(length)), eof);
+      if (inner) return inner;
     }
-    return inner;
+    return this._inner.decode(EMPTY_BYTES, eof);
   }
   reset() {
     this._isFirstTls = true;

package/network/mtproxy/_fake-tls.test.d.cts

@@ -0,0 +1 @@
+export {};

package/network/mtproxy/_fake-tls.test.d.ts

@@ -0,0 +1 @@
+export {};

package/network/network-manager.cjs

@@ -227,7 +227,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.30.0",
+      appVersion: "0.30.1",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"

package/network/network-manager.js

@@ -220,7 +220,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.30.0",
+      appVersion: "0.30.1",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@mtcute/core",
     "type": "module",
-    "version": "0.30.0",
+    "version": "0.30.1",
     "description": "Type-safe library for MTProto (Telegram API)",
     "license": "MIT",
     "scripts": {},