@mtcute/core 0.17.1 → 0.18.0-rc.5

package/network/mtproto-session.js

@@ -0,0 +1,239 @@
+import { LruSet, Deque, timers } from "@fuman/utils";
+import { TlSerializationCounter } from "@mtcute/tl-runtime";
+import Long from "long";
+import { randomLong, LongSet, LongMap, compareLongs } from "../utils/long-utils.js";
+import { getRandomInt } from "../utils/misc-utils.js";
+import { SortedArray } from "../utils/sorted-array.js";
+import { AuthKey } from "./auth-key.js";
+import { MtcuteError } from "../types/errors.js";
+class MtprotoSession {
+  constructor(_crypto, log, _readerMap, _writerMap, _salts) {
+    this._crypto = _crypto;
+    this.log = log;
+    this._readerMap = _readerMap;
+    this._writerMap = _writerMap;
+    this._salts = _salts;
+    this.log.prefix = `[SESSION ${this._sessionId.toString(16)}] `;
+    this._authKey = new AuthKey(_crypto, log, _readerMap);
+    this._authKeyTemp = new AuthKey(_crypto, log, _readerMap);
+    this._authKeyTempSecondary = new AuthKey(_crypto, log, _readerMap);
+  }
+  _sessionId = randomLong();
+  _authKey;
+  _authKeyTemp;
+  _authKeyTempSecondary;
+  _timeOffset = 0;
+  _lastMessageId = Long.ZERO;
+  _seqNo = 0;
+  /// state ///
+  // recent msg ids
+  recentOutgoingMsgIds = new LruSet(1e3, LongSet);
+  recentIncomingMsgIds = new LruSet(1e3, LongSet);
+  // queues
+  queuedRpc = new Deque();
+  queuedAcks = [];
+  queuedStateReq = [];
+  queuedResendReq = [];
+  queuedCancelReq = [];
+  getStateSchedule = new SortedArray([], (a, b) => a.getState - b.getState);
+  chains = /* @__PURE__ */ new Map();
+  chainsPendingFails = /* @__PURE__ */ new Map();
+  // requests info
+  pendingMessages = new LongMap();
+  destroySessionIdToMsgId = new LongMap();
+  lastPingRtt = Number.NaN;
+  lastPingTime = 0;
+  lastPingMsgId = Long.ZERO;
+  lastSessionCreatedUid = Long.ZERO;
+  initConnectionCalled = false;
+  authorizationPending = false;
+  next429Timeout = 1e3;
+  current429Timeout;
+  next429ResetTimeout;
+  get hasPendingMessages() {
+    return Boolean(
+      this.queuedRpc.length || this.queuedAcks.length || this.queuedStateReq.length || this.queuedResendReq.length
+    );
+  }
+  /**
+   * Reset session by resetting auth key(s) and session state
+   */
+  reset(withAuthKey = false) {
+    if (withAuthKey) {
+      this.resetAuthKey();
+    }
+    timers.clearTimeout(this.current429Timeout);
+    this.resetState(withAuthKey);
+  }
+  resetAuthKey() {
+    this._authKey.reset();
+    this._authKeyTemp.reset();
+    this._authKeyTempSecondary.reset();
+  }
+  updateTimeOffset(offset) {
+    this.log.debug("time offset updated: %d", offset);
+    this._timeOffset = offset;
+    this._lastMessageId = Long.ZERO;
+  }
+  /**
+   * Reset session state and generate a new session ID.
+   *
+   * By default, also cancels any pending RPC requests.
+   * If `keepPending` is set to `true`, pending requests will be kept
+   */
+  resetState(keepPending = false) {
+    this._lastMessageId = Long.ZERO;
+    this._seqNo = 0;
+    this._sessionId = randomLong();
+    this.log.debug("session reset, new sid = %h", this._sessionId);
+    this.log.prefix = `[SESSION ${this._sessionId.toString(16)}] `;
+    if (!keepPending) {
+      for (const info of this.pendingMessages.values()) {
+        if (info._ === "rpc") {
+          this.log.debug("rejecting pending rpc %s", info.rpc.method);
+          info.rpc.promise.reject(new MtcuteError("Session is reset"));
+        }
+      }
+      this.pendingMessages.clear();
+    }
+    this.recentOutgoingMsgIds.clear();
+    this.recentIncomingMsgIds.clear();
+    if (!keepPending) {
+      while (this.queuedRpc.length) {
+        const rpc = this.queuedRpc.popFront();
+        if (rpc.sent === false) {
+          this.log.debug("rejecting pending rpc %s", rpc.method);
+          rpc.promise.reject(new MtcuteError("Session is reset"));
+        }
+      }
+    }
+    this.queuedAcks.length = 0;
+    this.queuedStateReq.length = 0;
+    this.queuedResendReq.length = 0;
+    this.queuedCancelReq.length = 0;
+    this.getStateSchedule.clear();
+    this.chains.clear();
+    this.chainsPendingFails.clear();
+    this.resetLastPing(true);
+  }
+  enqueueRpc(rpc, force) {
+    if (!force && !rpc.sent || rpc.cancelled) return false;
+    rpc.sent = false;
+    rpc.containerId = void 0;
+    this.log.debug("enqueued %s for sending (msg_id = %s)", rpc.method, rpc.msgId || "n/a");
+    this.queuedRpc.pushBack(rpc);
+    return true;
+  }
+  getMessageId() {
+    const timeTicks = Date.now();
+    const timeSec = Math.floor(timeTicks / 1e3) - this._timeOffset;
+    const timeMSec = timeTicks % 1e3;
+    const random = getRandomInt(65535);
+    let messageId = new Long(timeMSec << 21 | random << 3 | 4, timeSec);
+    if (this._lastMessageId.ge(messageId)) {
+      messageId = this._lastMessageId.add(4);
+    }
+    this._lastMessageId = messageId;
+    return messageId;
+  }
+  getSeqNo(isContentRelated = true) {
+    let seqNo = this._seqNo;
+    if (isContentRelated) {
+      seqNo += 1;
+      this._seqNo += 2;
+    }
+    return seqNo;
+  }
+  /** Encrypt a single MTProto message using session's keys */
+  encryptMessage(message) {
+    const key = this._authKeyTemp.ready ? this._authKeyTemp : this._authKey;
+    return key.encryptMessage(message, this._salts.currentSalt, this._sessionId);
+  }
+  /** Decrypt a single MTProto message using session's keys */
+  decryptMessage(data, callback) {
+    if (!this._authKey.ready) throw new MtcuteError("Keys are not set up!");
+    const authKeyId = data.subarray(0, 8);
+    let key;
+    if (this._authKey.match(authKeyId)) {
+      key = this._authKey;
+    } else if (this._authKeyTemp.match(authKeyId)) {
+      key = this._authKeyTemp;
+    } else if (this._authKeyTempSecondary.match(authKeyId)) {
+      key = this._authKeyTempSecondary;
+    } else {
+      this.log.warn(
+        "received message with unknown authKey = %h (expected %h or %h or %h)",
+        authKeyId,
+        this._authKey.id,
+        this._authKeyTemp.id,
+        this._authKeyTempSecondary.id
+      );
+      return;
+    }
+    return key.decryptMessage(data, this._sessionId, callback);
+  }
+  writeMessage(writer, content, isContentRelated = true) {
+    const messageId = this.getMessageId();
+    const seqNo = this.getSeqNo(isContentRelated);
+    const length = ArrayBuffer.isView(content) ? content.length : TlSerializationCounter.countNeededBytes(writer.objectMap, content);
+    writer.long(messageId);
+    writer.int(seqNo);
+    writer.uint(length);
+    if (ArrayBuffer.isView(content)) writer.raw(content);
+    else writer.object(content);
+    return messageId;
+  }
+  onTransportFlood(callback) {
+    if (this.current429Timeout) return;
+    this.resetLastPing(true);
+    const timeout = this.next429Timeout;
+    this.next429Timeout = Math.min(this.next429Timeout * 2, 32e3);
+    timers.clearTimeout(this.current429Timeout);
+    timers.clearTimeout(this.next429ResetTimeout);
+    this.current429Timeout = timers.setTimeout(() => {
+      this.current429Timeout = void 0;
+      callback();
+    }, timeout);
+    this.next429ResetTimeout = timers.setTimeout(() => {
+      this.next429ResetTimeout = void 0;
+      this.next429Timeout = 1e3;
+    }, 6e4);
+    this.log.debug("transport flood, waiting for %d ms before proceeding", timeout);
+    return Date.now() + timeout;
+  }
+  resetLastPing(withTime = false) {
+    if (withTime) this.lastPingTime = 0;
+    if (!this.lastPingMsgId.isZero()) {
+      this.pendingMessages.delete(this.lastPingMsgId);
+    }
+    this.lastPingMsgId = Long.ZERO;
+  }
+  addToChain(chainId, msgId) {
+    const prevMsgId = this.chains.get(chainId);
+    this.chains.set(chainId, msgId);
+    this.log.debug("added message %l to chain %s (prev: %l)", msgId, chainId, prevMsgId);
+    return prevMsgId;
+  }
+  removeFromChain(chainId, msgId) {
+    const lastMsgId = this.chains.get(chainId);
+    if (!lastMsgId) {
+      this.log.warn("tried to remove message %l from empty chain %s", msgId, chainId);
+      return;
+    }
+    if (lastMsgId.eq(msgId)) {
+      this.log.debug("chain %s: exhausted, last message %l", chainId, msgId);
+      this.chains.delete(chainId);
+    }
+  }
+  getPendingChainedFails(chainId) {
+    let arr = this.chainsPendingFails.get(chainId);
+    if (!arr) {
+      arr = new SortedArray([], (a, b) => compareLongs(a.invokeAfter, b.invokeAfter));
+      this.chainsPendingFails.set(chainId, arr);
+    }
+    return arr;
+  }
+}
+export {
+  MtprotoSession
+};

package/network/mtproxy/_fake-tls.cjs

@@ -0,0 +1,327 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const utils = require("@fuman/utils");
+const MAX_TLS_PACKET_LENGTH = 2878;
+const KEY_MOD = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDn;
+const QUAD_RES_MOD = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDn;
+const QUAD_RES_POW = 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6n;
+function _getY2(x, mod) {
+  let y = x;
+  y = (y + 486662n) % mod;
+  y = y * x % mod;
+  y = (y + 1n) % mod;
+  y = y * x % mod;
+  return y;
+}
+function _getDoubleX(x, mod) {
+  let denominator = _getY2(x, mod);
+  denominator = denominator * 4n % mod;
+  let numerator = x * x % mod;
+  numerator = (numerator - 1n) % mod;
+  numerator = numerator * numerator % mod;
+  denominator = utils.bigint.modInv(denominator, mod);
+  numerator = numerator * denominator % mod;
+  return numerator;
+}
+function _isQuadraticResidue(a) {
+  const r = utils.bigint.modPowBinary(a, QUAD_RES_POW, QUAD_RES_MOD);
+  return r === 1n;
+}
+function executeTlsOperations(h) {
+  h.string([22, 3, 1, 2, 0, 1, 0, 1, 252, 3, 3]);
+  h.zero(32);
+  h.string([32]);
+  h.random(32);
+  h.string([0, 32]);
+  h.grease(0);
+  h.string([
+    19,
+    1,
+    19,
+    2,
+    19,
+    3,
+    192,
+    43,
+    192,
+    47,
+    192,
+    44,
+    192,
+    48,
+    204,
+    169,
+    204,
+    168,
+    192,
+    19,
+    192,
+    20,
+    0,
+    156,
+    0,
+    157,
+    0,
+    47,
+    0,
+    53,
+    1,
+    0,
+    1,
+    147
+  ]);
+  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,
+      0,
+      13,
+      0,
+      18,
+      0,
+      16,
+      4,
+      3,
+      8,
+      4,
+      4,
+      1,
+      5,
+      3,
+      8,
+      5,
+      5,
+      1,
+      8,
+      6,
+      6,
+      1,
+      0,
+      18,
+      0,
+      0,
+      0,
+      51,
+      0,
+      43,
+      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]);
+  h.grease(3);
+  h.string([0, 1, 0, 0, 21]);
+}
+function initGrease(crypto, size) {
+  const buf = crypto.randomBytes(size);
+  for (let i = 0; i < size; i++) {
+    buf[i] = (buf[i] & 240) + 10;
+  }
+  for (let i = 1; i < size; i += 2) {
+    if (buf[i] === buf[i - 1]) {
+      buf[i] ^= 16;
+    }
+  }
+  return buf;
+}
+class TlsHelloWriter {
+  constructor(crypto, size, domain) {
+    this.crypto = crypto;
+    this._domain = domain;
+    this.buf = utils.u8.alloc(size);
+    this.dv = utils.typed.toDataView(this.buf);
+    this._grease = initGrease(this.crypto, 7);
+  }
+  buf;
+  dv;
+  pos = 0;
+  _domain;
+  _grease;
+  _scopes = [];
+  string(buf) {
+    this.buf.set(buf, this.pos);
+    this.pos += buf.length;
+  }
+  random(size) {
+    this.string(this.crypto.randomBytes(size));
+  }
+  zero(size) {
+    this.pos += size;
+  }
+  domain() {
+    this.string(this._domain);
+  }
+  grease(seed) {
+    this.buf[this.pos] = this.buf[this.pos + 1] = this._grease[seed];
+    this.pos += 2;
+  }
+  key() {
+    for (; ; ) {
+      const key = this.crypto.randomBytes(32);
+      key[31] &= 127;
+      let x = utils.bigint.fromBytes(key);
+      const y = _getY2(x, KEY_MOD);
+      if (_isQuadraticResidue(y)) {
+        for (let i = 0; i < 3; i++) {
+          x = _getDoubleX(x, KEY_MOD);
+        }
+        const key2 = utils.bigint.toBytes(x, 32, true);
+        this.string(key2);
+        return;
+      }
+    }
+  }
+  beginScope() {
+    this._scopes.push(this.pos);
+    this.pos += 2;
+  }
+  endScope() {
+    const begin = this._scopes.pop();
+    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);
+  }
+  async finish(secret) {
+    const padSize = 515 - this.pos;
+    const unixTime = ~~(Date.now() / 1e3);
+    this.beginScope();
+    this.zero(padSize);
+    this.endScope();
+    const hash = await this.crypto.hmacSha256(this.buf, 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;
+  }
+}
+async function generateFakeTlsHeader(domain, secret, crypto) {
+  const writer = new TlsHelloWriter(crypto, 517, domain);
+  executeTlsOperations(writer);
+  return writer.finish(secret);
+}
+class FakeTlsPacketCodec {
+  // protected _stream: Buffer = Buffer.alloc(0)
+  constructor(_inner) {
+    this._inner = _inner;
+  }
+  _isFirstTls = true;
+  setup(crypto, log) {
+    this._inner.setup?.(crypto, log);
+  }
+  _tag;
+  async tag() {
+    this._tag = await this._inner.tag();
+    return new Uint8Array(0);
+  }
+  async encode(packet, into) {
+    const tmp = io.Bytes.alloc(packet.length);
+    await this._inner.encode(packet, tmp);
+    while (tmp.available > 0) {
+      const header = new Uint8Array([23, 3, 3, 0, 0]);
+      let packet2;
+      if (this._isFirstTls) {
+        this._isFirstTls = false;
+        packet2 = utils.u8.concat2(this._tag, tmp.readSync(MAX_TLS_PACKET_LENGTH - this._tag.length));
+      } else {
+        packet2 = tmp.readSync(MAX_TLS_PACKET_LENGTH);
+      }
+      utils.typed.toDataView(header).setUint16(3, packet2.length);
+      into.writeSync(header.length).set(header);
+      into.writeSync(packet2.length).set(packet2);
+      into.disposeWriteSync();
+    }
+  }
+  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;
+    }
+    return inner;
+  }
+  reset() {
+    this._isFirstTls = true;
+  }
+}
+exports.FakeTlsPacketCodec = FakeTlsPacketCodec;
+exports.generateFakeTlsHeader = generateFakeTlsHeader;

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

@@ -0,0 +1,22 @@
+import { ICryptoProvider } from '../../utils/crypto/abstract.js';
+import { Logger } from '../../utils/logger.js';
+import { IPacketCodec } from '../transports/index.js';
+import { Bytes, ISyncWritable } from '@fuman/io';
+export declare function generateFakeTlsHeader(domain: Uint8Array, secret: Uint8Array, crypto: ICryptoProvider): Promise<Uint8Array>;
+/**
+ * Fake TLS packet codec, used for some MTProxies.
+ *
+ * Must only be used inside {@link MtProxyTcpTransport}
+ * @internal
+ */
+export declare class FakeTlsPacketCodec implements IPacketCodec {
+    readonly _inner: IPacketCodec;
+    constructor(_inner: IPacketCodec);
+    private _isFirstTls;
+    setup?(crypto: ICryptoProvider, log: Logger): void;
+    private _tag;
+    tag(): Promise<Uint8Array>;
+    encode(packet: Uint8Array, into: ISyncWritable): Promise<void>;
+    decode(reader: Bytes, eof: boolean): Promise<Uint8Array | null>;
+    reset(): void;
+}