@mtcute/core 0.30.0 → 0.30.2

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/multi-session-connection.cjs

@@ -160,6 +160,13 @@ class MultiSessionConnection {
     if (this._connections[0].isConnected) return;
     this.connect();
   }
+  get isConnected() {
+    return this._connections.some((conn) => conn.isConnected);
+  }
+  destroyAuthKey() {
+    const conn = this._connections.find((c) => c.isConnected) ?? this._connections[0];
+    conn?.destroyAuthKey();
+  }
   _authKey = null;
   setAuthKey(authKey) {
     this._authKey = authKey;

package/network/multi-session-connection.d.cts

@@ -29,6 +29,8 @@ export declare class MultiSessionConnection {
     sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
     connect(): void;
     ensureConnected(): void;
+    get isConnected(): boolean;
+    destroyAuthKey(): void;
     private _authKey;
     setAuthKey(authKey: Uint8Array | null): void;
     setTempAuthKey(authKey: Uint8Array | null, idx: number): void;

package/network/multi-session-connection.d.ts

@@ -29,6 +29,8 @@ export declare class MultiSessionConnection {
     sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
     connect(): void;
     ensureConnected(): void;
+    get isConnected(): boolean;
+    destroyAuthKey(): void;
     private _authKey;
     setAuthKey(authKey: Uint8Array | null): void;
     setTempAuthKey(authKey: Uint8Array | null, idx: number): void;

package/network/multi-session-connection.js

@@ -153,6 +153,13 @@ class MultiSessionConnection {
     if (this._connections[0].isConnected) return;
     this.connect();
   }
+  get isConnected() {
+    return this._connections.some((conn) => conn.isConnected);
+  }
+  destroyAuthKey() {
+    const conn = this._connections.find((c) => c.isConnected) ?? this._connections[0];
+    conn?.destroyAuthKey();
+  }
   _authKey = null;
   setAuthKey(authKey) {
     this._authKey = authKey;

package/network/network-manager.cjs

@@ -227,7 +227,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.30.0",
+      appVersion: "0.30.2",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"
@@ -415,6 +415,12 @@ class NetworkManager {
     return user;
   }
   notifyLoggedOut() {
+    const primaryDcId = this._primaryDc?.dcId;
+    for (const dc of this._dcConnections.values()) {
+      if (dc.dcId === primaryDcId) continue;
+      const pool = [dc.main, dc.download, dc.upload, dc.downloadSmall].find((p) => p.isConnected);
+      pool?.destroyAuthKey();
+    }
     this._businessConnectionDcs.clear();
     this.setIsPremium(false);
     this.resetSessions();

package/network/network-manager.js

@@ -220,7 +220,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.30.0",
+      appVersion: "0.30.2",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"
@@ -408,6 +408,12 @@ class NetworkManager {
     return user;
   }
   notifyLoggedOut() {
+    const primaryDcId = this._primaryDc?.dcId;
+    for (const dc of this._dcConnections.values()) {
+      if (dc.dcId === primaryDcId) continue;
+      const pool = [dc.main, dc.download, dc.upload, dc.downloadSmall].find((p) => p.isConnected);
+      pool?.destroyAuthKey();
+    }
     this._businessConnectionDcs.clear();
     this.setIsPremium(false);
     this.resetSessions();

package/network/resource-limiter.cjs

@@ -0,0 +1,60 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+class ResourceLimiter {
+  constructor(max) {
+    this.max = max;
+    this._available = max;
+  }
+  _available;
+  _waiters = [];
+  setMax(max) {
+    this._available += max - this.max;
+    this.max = max;
+    this._pump();
+  }
+  tryAcquire(bytes) {
+    if (bytes > this.max) bytes = this.max;
+    if (!this._waiters.length && this._available >= bytes) {
+      this._available -= bytes;
+      return true;
+    }
+    return false;
+  }
+  acquire(bytes, signal) {
+    if (this.tryAcquire(bytes)) return Promise.resolve();
+    if (bytes > this.max) bytes = this.max;
+    const deferred = new utils.Deferred();
+    const waiter = { need: bytes, deferred };
+    this._waiters.push(waiter);
+    if (signal) {
+      const onAbort = () => {
+        const idx = this._waiters.indexOf(waiter);
+        if (idx >= 0) this._waiters.splice(idx, 1);
+        deferred.reject(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      const removeListener = signal.removeEventListener.bind(signal, "abort", onAbort);
+      deferred.promise.then(removeListener, removeListener);
+    }
+    return deferred.promise;
+  }
+  release(bytes) {
+    if (bytes > this.max) bytes = this.max;
+    this._available += bytes;
+    this._pump();
+  }
+  _pump() {
+    while (this._waiters.length && this._waiters[0].need <= this._available) {
+      const waiter = this._waiters.shift();
+      this._available -= waiter.need;
+      waiter.deferred.resolve();
+    }
+  }
+}
+exports.ResourceLimiter = ResourceLimiter;

package/network/resource-limiter.d.cts

@@ -0,0 +1,11 @@
+export declare class ResourceLimiter {
+    max: number;
+    private _available;
+    private _waiters;
+    constructor(max: number);
+    setMax(max: number): void;
+    tryAcquire(bytes: number): boolean;
+    acquire(bytes: number, signal?: AbortSignal): Promise<void>;
+    release(bytes: number): void;
+    private _pump;
+}

package/network/resource-limiter.d.ts

@@ -0,0 +1,11 @@
+export declare class ResourceLimiter {
+    max: number;
+    private _available;
+    private _waiters;
+    constructor(max: number);
+    setMax(max: number): void;
+    tryAcquire(bytes: number): boolean;
+    acquire(bytes: number, signal?: AbortSignal): Promise<void>;
+    release(bytes: number): void;
+    private _pump;
+}

package/network/resource-limiter.js

@@ -0,0 +1,55 @@
+import { Deferred } from "@fuman/utils";
+class ResourceLimiter {
+  constructor(max) {
+    this.max = max;
+    this._available = max;
+  }
+  _available;
+  _waiters = [];
+  setMax(max) {
+    this._available += max - this.max;
+    this.max = max;
+    this._pump();
+  }
+  tryAcquire(bytes) {
+    if (bytes > this.max) bytes = this.max;
+    if (!this._waiters.length && this._available >= bytes) {
+      this._available -= bytes;
+      return true;
+    }
+    return false;
+  }
+  acquire(bytes, signal) {
+    if (this.tryAcquire(bytes)) return Promise.resolve();
+    if (bytes > this.max) bytes = this.max;
+    const deferred = new Deferred();
+    const waiter = { need: bytes, deferred };
+    this._waiters.push(waiter);
+    if (signal) {
+      const onAbort = () => {
+        const idx = this._waiters.indexOf(waiter);
+        if (idx >= 0) this._waiters.splice(idx, 1);
+        deferred.reject(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      const removeListener = signal.removeEventListener.bind(signal, "abort", onAbort);
+      deferred.promise.then(removeListener, removeListener);
+    }
+    return deferred.promise;
+  }
+  release(bytes) {
+    if (bytes > this.max) bytes = this.max;
+    this._available += bytes;
+    this._pump();
+  }
+  _pump() {
+    while (this._waiters.length && this._waiters[0].need <= this._available) {
+      const waiter = this._waiters.shift();
+      this._available -= waiter.need;
+      waiter.deferred.resolve();
+    }
+  }
+}
+export {
+  ResourceLimiter
+};

package/network/resource-limiter.test.d.cts

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

package/network/resource-limiter.test.d.ts

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

package/network/server-salt.cjs

@@ -11,12 +11,16 @@ class ServerSaltManager {
   _futureSalts = [];
   currentSalt = Long.ZERO;
   isFetching = false;
+  _getServerTime = () => Date.now() / 1e3;
+  setTimeSource(fn) {
+    this._getServerTime = fn;
+  }
   shouldFetchSalts() {
     return !this.isFetching && !this.currentSalt.isZero() && this._futureSalts.length < 2;
   }
   setFutureSalts(salts) {
     this._futureSalts = salts;
-    const now = Date.now() / 1e3;
+    const now = this._getServerTime();
     while (salts.length > 0 && salts[0].validSince <= now) {
       this.currentSalt = salts[0].salt;
       this._futureSalts.shift();
@@ -30,11 +34,11 @@ class ServerSaltManager {
     this._timer = utils.timers.setTimeout(() => {
       this.currentSalt = salt.salt;
       this._replaceAndScheduleNext();
-    }, salt.validSince * 1e3 - Date.now());
+    }, (salt.validSince - this._getServerTime()) * 1e3);
   }
   _replaceAndScheduleNext() {
     if (this._timer) utils.timers.clearTimeout(this._timer);
-    const now = Date.now() / 1e3;
+    const now = this._getServerTime();
     while (this._futureSalts.length !== 0) {
       const salt = this._futureSalts[0];
       if (salt.validSince > now) break;

package/network/server-salt.d.cts

@@ -4,6 +4,8 @@ export declare class ServerSaltManager {
     private _futureSalts;
     currentSalt: Long;
     isFetching: boolean;
+    private _getServerTime;
+    setTimeSource(fn: () => number): void;
     shouldFetchSalts(): boolean;
     setFutureSalts(salts: mtp.RawMt_future_salt[]): void;
     private _timer?;

package/network/server-salt.d.ts

@@ -4,6 +4,8 @@ export declare class ServerSaltManager {
     private _futureSalts;
     currentSalt: Long;
     isFetching: boolean;
+    private _getServerTime;
+    setTimeSource(fn: () => number): void;
     shouldFetchSalts(): boolean;
     setFutureSalts(salts: mtp.RawMt_future_salt[]): void;
     private _timer?;

package/network/server-salt.js

@@ -4,12 +4,16 @@ class ServerSaltManager {
   _futureSalts = [];
   currentSalt = Long.ZERO;
   isFetching = false;
+  _getServerTime = () => Date.now() / 1e3;
+  setTimeSource(fn) {
+    this._getServerTime = fn;
+  }
   shouldFetchSalts() {
     return !this.isFetching && !this.currentSalt.isZero() && this._futureSalts.length < 2;
   }
   setFutureSalts(salts) {
     this._futureSalts = salts;
-    const now = Date.now() / 1e3;
+    const now = this._getServerTime();
     while (salts.length > 0 && salts[0].validSince <= now) {
       this.currentSalt = salts[0].salt;
       this._futureSalts.shift();
@@ -23,11 +27,11 @@ class ServerSaltManager {
     this._timer = timers.setTimeout(() => {
       this.currentSalt = salt.salt;
       this._replaceAndScheduleNext();
-    }, salt.validSince * 1e3 - Date.now());
+    }, (salt.validSince - this._getServerTime()) * 1e3);
   }
   _replaceAndScheduleNext() {
     if (this._timer) timers.clearTimeout(this._timer);
-    const now = Date.now() / 1e3;
+    const now = this._getServerTime();
     while (this._futureSalts.length !== 0) {
       const salt = this._futureSalts[0];
       if (salt.validSince > now) break;