@mtcute/core 0.30.0 → 0.30.2

package/network/middlewares/media-throttle.js

@@ -0,0 +1,60 @@
+import { combineAbortSignals } from "../../utils/abort-signal.js";
+import { ResourceLimiter } from "../resource-limiter.js";
+const DOWNLOAD_RESOURCE_LIMIT = 2 * 1024 * 1024;
+const DOWNLOAD_RESOURCE_LIMIT_PREMIUM = 16 * 1024 * 1024;
+const UPLOAD_RESOURCE_LIMIT = 4 * 1024 * 1024;
+function defaultResourceLimit(kind, isPremium) {
+  if (kind === "upload") return UPLOAD_RESOURCE_LIMIT;
+  return isPremium ? DOWNLOAD_RESOURCE_LIMIT_PREMIUM : DOWNLOAD_RESOURCE_LIMIT;
+}
+function mediaThrottle(params) {
+  const { getResourceLimit = defaultResourceLimit } = params ?? {};
+  const limiters = /* @__PURE__ */ new Map();
+  const getLimiter = (kind, dcId, isPremium) => {
+    let byDc = limiters.get(kind);
+    if (!byDc) {
+      byDc = /* @__PURE__ */ new Map();
+      limiters.set(kind, byDc);
+    }
+    const max = getResourceLimit(kind, isPremium);
+    let limiter = byDc.get(dcId);
+    if (!limiter) {
+      limiter = new ResourceLimiter(max);
+      byDc.set(dcId, limiter);
+    } else if (limiter.max !== max) {
+      limiter.setMax(max);
+    }
+    return limiter;
+  };
+  return async (ctx, next) => {
+    let kind;
+    let bytes = 0;
+    switch (ctx.request._) {
+      case "upload.getFile":
+      case "upload.getWebFile":
+        kind = ctx.params?.kind ?? "download";
+        bytes = ctx.request.limit;
+        break;
+      case "upload.saveFilePart":
+      case "upload.saveBigFilePart":
+        kind = "upload";
+        bytes = ctx.request.bytes.length;
+        break;
+    }
+    if (kind === void 0) return next(ctx);
+    const dcId = ctx.params?.dcId ?? ctx.manager.getPrimaryDcId();
+    const limiter = getLimiter(kind, dcId, ctx.manager.params.isPremium);
+    if (!limiter.tryAcquire(bytes)) {
+      const abortSignal = combineAbortSignals(ctx.manager.params.stopSignal, ctx.params?.abortSignal);
+      await limiter.acquire(bytes, abortSignal);
+    }
+    try {
+      return await next(ctx);
+    } finally {
+      limiter.release(bytes);
+    }
+  };
+}
+export {
+  mediaThrottle
+};

package/network/middlewares/media-throttle.test.d.cts

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

package/network/middlewares/media-throttle.test.d.ts

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

package/network/middlewares/on-error.test.d.cts

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

package/network/middlewares/on-error.test.d.ts

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

package/network/middlewares/on-method.test.d.cts

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

package/network/middlewares/on-method.test.d.ts

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

package/network/mtproto-session.cjs

@@ -12,6 +12,7 @@ const longUtils = require("../utils/long-utils.cjs");
 const miscUtils = require("../utils/misc-utils.cjs");
 const sortedArray = require("../utils/sorted-array.cjs");
 const authKey = require("./auth-key.cjs");
+const messageIdStore = require("./message-id-store.cjs");
 const errors = require("../types/errors.cjs");
 class MtprotoSession {
   constructor(_crypto, log, _readerMap, _writerMap, _salts) {
@@ -21,6 +22,7 @@ class MtprotoSession {
     this._writerMap = _writerMap;
     this._salts = _salts;
     this.log.prefix = `[SESSION ${this._sessionId.toString(16)}] `;
+    this._salts.setTimeSource(this.getServerTime.bind(this));
     this._authKey = new authKey.AuthKey(_crypto, log, _readerMap);
     this._authKeyTemp = new authKey.AuthKey(_crypto, log, _readerMap);
     this._authKeyTempSecondary = new authKey.AuthKey(_crypto, log, _readerMap);
@@ -35,7 +37,7 @@ class MtprotoSession {
   /// state ///
   // recent msg ids
   recentOutgoingMsgIds = new utils.LruSet(1e3, longUtils.LongSet);
-  recentIncomingMsgIds = new utils.LruSet(1e3, longUtils.LongSet);
+  recentIncomingMsgIds = new messageIdStore.MessageIdStore();
   // <deno-tsignore>
   recentStateRequests = new utils.LruMap(1e3, longUtils.LongMap);
   // queues
@@ -58,6 +60,7 @@ class MtprotoSession {
   lastPingRtt = Number.NaN;
   lastPingTime = 0;
   lastPingMsgId = Long.ZERO;
+  lastActivityTime = 0;
   lastSessionCreatedUid = Long.ZERO;
   initConnectionCalled = false;
   authorizationPending = false;
@@ -80,11 +83,15 @@ class MtprotoSession {
     this._authKeyTemp.reset();
     this._authKeyTempSecondary.reset();
   }
-  updateTimeOffset(offset) {
+  updateTimeOffset(offset, force = false) {
+    if (!force && offset <= this._timeOffset) return;
     this.log.debug("time offset updated: %d", offset);
     this._timeOffset = offset;
     this._lastMessageId = Long.ZERO;
   }
+  getServerTime() {
+    return Math.floor(performance.now() / 1e3) + this._timeOffset;
+  }
   /**
    * Reset session state and generate a new session ID.
    *

package/network/mtproto-session.d.cts

@@ -5,6 +5,7 @@ import { ICryptoProvider, Logger, LongMap, SortedArray } from '../utils/index.js
 import { ServerSaltManager } from './server-salt.js';
 import { default as Long } from 'long';
 import { AuthKey } from './auth-key.js';
+import { MessageIdStore } from './message-id-store.js';
 export interface PendingRpc {
     method: string;
     data: Uint8Array;
@@ -76,7 +77,7 @@ export declare class MtprotoSession {
     _lastMessageId: Long;
     _seqNo: number;
     recentOutgoingMsgIds: LruSet<Long>;
-    recentIncomingMsgIds: LruSet<Long>;
+    recentIncomingMsgIds: MessageIdStore;
     recentStateRequests: LruMap<Long, Long[]>;
     queuedRpc: Deque<PendingRpc>;
     queuedAcks: Long[];
@@ -91,6 +92,7 @@ export declare class MtprotoSession {
     lastPingRtt: number;
     lastPingTime: number;
     lastPingMsgId: Long;
+    lastActivityTime: number;
     lastSessionCreatedUid: Long;
     initConnectionCalled: boolean;
     authorizationPending: boolean;
@@ -101,7 +103,8 @@ export declare class MtprotoSession {
      */
     reset(withAuthKey?: boolean): void;
     resetAuthKey(): void;
-    updateTimeOffset(offset: number): void;
+    updateTimeOffset(offset: number, force?: boolean): void;
+    getServerTime(): number;
     /**
      * Reset session state and generate a new session ID.
      *

package/network/mtproto-session.d.ts

@@ -5,6 +5,7 @@ import { ICryptoProvider, Logger, LongMap, SortedArray } from '../utils/index.js
 import { ServerSaltManager } from './server-salt.js';
 import { default as Long } from 'long';
 import { AuthKey } from './auth-key.js';
+import { MessageIdStore } from './message-id-store.js';
 export interface PendingRpc {
     method: string;
     data: Uint8Array;
@@ -76,7 +77,7 @@ export declare class MtprotoSession {
     _lastMessageId: Long;
     _seqNo: number;
     recentOutgoingMsgIds: LruSet<Long>;
-    recentIncomingMsgIds: LruSet<Long>;
+    recentIncomingMsgIds: MessageIdStore;
     recentStateRequests: LruMap<Long, Long[]>;
     queuedRpc: Deque<PendingRpc>;
     queuedAcks: Long[];
@@ -91,6 +92,7 @@ export declare class MtprotoSession {
     lastPingRtt: number;
     lastPingTime: number;
     lastPingMsgId: Long;
+    lastActivityTime: number;
     lastSessionCreatedUid: Long;
     initConnectionCalled: boolean;
     authorizationPending: boolean;
@@ -101,7 +103,8 @@ export declare class MtprotoSession {
      */
     reset(withAuthKey?: boolean): void;
     resetAuthKey(): void;
-    updateTimeOffset(offset: number): void;
+    updateTimeOffset(offset: number, force?: boolean): void;
+    getServerTime(): number;
     /**
      * Reset session state and generate a new session ID.
      *

package/network/mtproto-session.js

@@ -5,6 +5,7 @@ import { randomLong, LongSet, LongMap, compareLongs } from "../utils/long-utils.
 import { getRandomInt } from "../utils/misc-utils.js";
 import { SortedArray } from "../utils/sorted-array.js";
 import { AuthKey } from "./auth-key.js";
+import { MessageIdStore } from "./message-id-store.js";
 import { MtcuteError } from "../types/errors.js";
 class MtprotoSession {
   constructor(_crypto, log, _readerMap, _writerMap, _salts) {
@@ -14,6 +15,7 @@ class MtprotoSession {
     this._writerMap = _writerMap;
     this._salts = _salts;
     this.log.prefix = `[SESSION ${this._sessionId.toString(16)}] `;
+    this._salts.setTimeSource(this.getServerTime.bind(this));
     this._authKey = new AuthKey(_crypto, log, _readerMap);
     this._authKeyTemp = new AuthKey(_crypto, log, _readerMap);
     this._authKeyTempSecondary = new AuthKey(_crypto, log, _readerMap);
@@ -28,7 +30,7 @@ class MtprotoSession {
   /// state ///
   // recent msg ids
   recentOutgoingMsgIds = new LruSet(1e3, LongSet);
-  recentIncomingMsgIds = new LruSet(1e3, LongSet);
+  recentIncomingMsgIds = new MessageIdStore();
   // <deno-tsignore>
   recentStateRequests = new LruMap(1e3, LongMap);
   // queues
@@ -51,6 +53,7 @@ class MtprotoSession {
   lastPingRtt = Number.NaN;
   lastPingTime = 0;
   lastPingMsgId = Long.ZERO;
+  lastActivityTime = 0;
   lastSessionCreatedUid = Long.ZERO;
   initConnectionCalled = false;
   authorizationPending = false;
@@ -73,11 +76,15 @@ class MtprotoSession {
     this._authKeyTemp.reset();
     this._authKeyTempSecondary.reset();
   }
-  updateTimeOffset(offset) {
+  updateTimeOffset(offset, force = false) {
+    if (!force && offset <= this._timeOffset) return;
     this.log.debug("time offset updated: %d", offset);
     this._timeOffset = offset;
     this._lastMessageId = Long.ZERO;
   }
+  getServerTime() {
+    return Math.floor(performance.now() / 1e3) + this._timeOffset;
+  }
   /**
    * Reset session state and generate a new session ID.
    *

package/network/mtproxy/_fake-tls.cjs

@@ -8,6 +8,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const io = require("@fuman/io");
 const utils = require("@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;
@@ -34,7 +35,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);
@@ -72,67 +77,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,
@@ -154,27 +126,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);
@@ -189,12 +210,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 = utils.u8.alloc(size);
+    this.buf = utils.u8.alloc(MAX_TLS_HELLO_SIZE);
     this.dv = utils.typed.toDataView(this.buf);
-    this._grease = initGrease(this.crypto, 7);
+    this._grease = grease ?? initGrease(this.crypto, 7);
   }
   buf;
   dv;
@@ -235,6 +256,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 = utils.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;
@@ -244,29 +283,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 utils.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 = utils.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 = io.Bytes.from(utils.u8.empty);
 class FakeTlsPacketCodec {
   // protected _stream: Buffer = Buffer.alloc(0)
   constructor(_inner) {
@@ -301,23 +366,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 = io.read.uint16be(reader);
-    if (length < reader.available - 5) {
-      reader.rewind(5);
-      return null;
-    }
-    const packet = reader.readSync(length);
-    const inner = await this._inner.decode(io.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 = io.read.uint16be(reader);
+      if (reader.available < length) {
+        reader.rewind(5);
+        break;
+      }
+      const inner = await this._inner.decode(io.Bytes.from(reader.readSync(length)), eof);
+      if (inner) return inner;
     }
-    return inner;
+    return this._inner.decode(EMPTY_BYTES, eof);
   }
   reset() {
     this._isFirstTls = true;