@mtkruto/node 0.1.0 → 0.1.100

package/esm/transport/0_obfuscation.js

@@ -22,7 +22,7 @@ export async function getObfuscationParameters(protocol, connection) {
     const encryptKey = init.slice(8, 8 + 32);
     const encryptIv = init.slice(40, 40 + 16);
     const encryptionCTR = new CTR(encryptKey, encryptIv);
-    const encryptedInit = encryptionCTR.encrypt(init);
+    const encryptedInit = encryptionCTR.call(init);
     const initRev = new Uint8Array(init).reverse();
     const decryptKey = initRev.slice(8, 8 + 32);
     const decryptIv = initRev.slice(40, 40 + 16);

package/esm/transport/0_transport.js

@@ -15,7 +15,7 @@ export class Transport {
     }
     encrypt(buffer) {
         if (this.obfuscationParameters) {
-            return this.obfuscationParameters.encryptionCTR.encrypt(buffer);
+            return this.obfuscationParameters.encryptionCTR.call(buffer);
         }
         else {
             return buffer;
@@ -23,7 +23,7 @@ export class Transport {
     }
     decrypt(buffer) {
         if (this.obfuscationParameters) {
-            return this.obfuscationParameters.decryptionCTR.decrypt(buffer);
+            return this.obfuscationParameters.decryptionCTR.call(buffer);
         }
         else {
             return buffer;

package/esm/utilities/0_crypto.d.ts

@@ -3,6 +3,5 @@ export declare class CTR {
     iv: Uint8Array;
     state: Uint8Array;
     constructor(key: Uint8Array, iv: Uint8Array);
-    encrypt(data: Uint8Array): Uint8Array;
-    decrypt(data: Uint8Array): Uint8Array;
+    call(data: Uint8Array): Uint8Array;
 }

package/esm/utilities/0_crypto.js

@@ -1,4 +1,4 @@
-import { ctr256Decrypt, ctr256Encrypt } from "../0_deps.js";
+import { ctr256 } from "../0_deps.js";
 export class CTR {
     constructor(key, iv) {
         Object.defineProperty(this, "key", {
@@ -20,18 +20,9 @@ export class CTR {
             value: new Uint8Array(1)
         });
     }
-    encrypt(data) {
+    call(data) {
         const v = new Uint8Array(data); // TODO: don't copy
-        const [iv, state] = ctr256Encrypt(v, this.key, this.iv, this.state);
-        this.iv = iv;
-        this.state = state;
-        return v;
-    }
-    decrypt(data) {
-        const v = new Uint8Array(data); // TODO: don't copy
-        const [iv, state] = ctr256Decrypt(v, this.key, this.iv, this.state);
-        this.iv = iv;
-        this.state = state;
+        ctr256(v, this.key, this.iv, this.state);
         return v;
     }
 }

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "@mtkruto/node",
-  "version": "0.1.0",
+  "version": "0.1.100",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/0_deps.d.ts

@@ -1,5 +1,5 @@
 export * from "./deps/deno.land/std@0.201.0/assert/mod.js";
-export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.2.1/mod.js";
+export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.2/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/main/gzip/gzip.js";
 export { Mutex, type MutexInterface } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";

package/script/0_deps.js

@@ -14,11 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.base64Encode = exports.base64Decode = exports.debug = exports.Parser = exports.Mutex = exports.gzip = exports.gunzip = exports.initTgCrypto = exports.ige256Encrypt = exports.ige256Decrypt = exports.factorize = exports.ctr256Encrypt = exports.ctr256Decrypt = void 0;
+exports.base64Encode = exports.base64Decode = exports.debug = exports.Parser = exports.Mutex = exports.gzip = exports.gunzip = exports.initTgCrypto = exports.ige256Encrypt = exports.ige256Decrypt = exports.factorize = exports.ctr256 = void 0;
 __exportStar(require("./deps/deno.land/std@0.201.0/assert/mod.js"), exports);
-var mod_js_1 = require("./deps/deno.land/x/tgcrypto@0.2.1/mod.js");
-Object.defineProperty(exports, "ctr256Decrypt", { enumerable: true, get: function () { return mod_js_1.ctr256Decrypt; } });
-Object.defineProperty(exports, "ctr256Encrypt", { enumerable: true, get: function () { return mod_js_1.ctr256Encrypt; } });
+var mod_js_1 = require("./deps/deno.land/x/tgcrypto@0.3.2/mod.js");
+Object.defineProperty(exports, "ctr256", { enumerable: true, get: function () { return mod_js_1.ctr256; } });
 Object.defineProperty(exports, "factorize", { enumerable: true, get: function () { return mod_js_1.factorize; } });
 Object.defineProperty(exports, "ige256Decrypt", { enumerable: true, get: function () { return mod_js_1.ige256Decrypt; } });
 Object.defineProperty(exports, "ige256Encrypt", { enumerable: true, get: function () { return mod_js_1.ige256Encrypt; } });

package/script/4_constants.d.ts

@@ -5,7 +5,7 @@ export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 161;
-export declare const APP_VERSION = "MTKruto 0.1.0";
+export declare const APP_VERSION = "MTKruto 0.1.100";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/script/4_constants.js

@@ -80,7 +80,7 @@ exports.PUBLIC_KEYS = Object.freeze([
 exports.VECTOR_CONSTRUCTOR = 0x1CB5C415;
 exports.INITIAL_DC = "2-test";
 exports.LAYER = 161;
-exports.APP_VERSION = "MTKruto 0.1.0";
+exports.APP_VERSION = "MTKruto 0.1.100";
 // @ts-ignore: lib
 exports.DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 exports.LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/script/deps/deno.land/x/{tgcrypto@0.2.1 → tgcrypto@0.3.2}/mod.d.ts

@@ -16,18 +16,14 @@ export declare function ige256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uin
  */
 export declare function ige256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array): Uint8Array;
 /**
- * Performs CTR-256 encryption.
+ * Performs CTR-256 encryption/decryption.
  *
  * @param data The data, larger than a byte
  * @param key 32-byte encryption key
  * @param iv 16-byte initialization vector
  * @param state 1-byte state
  */
-export declare function ctr256Encrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array];
-/**
- * Alias of `ctr256Encrypt`
- */
-export declare function ctr256Decrypt(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): [Uint8Array, Uint8Array];
+export declare function ctr256(data: Uint8Array, key: Uint8Array, iv: Uint8Array, state: Uint8Array): void;
 /**
  * Performs CBC-256 encryption.
  *

package/script/deps/deno.land/x/tgcrypto@0.3.2/mod.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorize = exports.cbc256Decrypt = exports.cbc256Encrypt = exports.ctr256 = exports.ige256Decrypt = exports.ige256Encrypt = exports.init = void 0;
+const tgcrypto_js_1 = __importDefault(require("./tgcrypto.js"));
+// deno-lint-ignore no-explicit-any
+let module_;
+const promise = (0, tgcrypto_js_1.default)().then((v) => module_ = v);
+async function init() {
+    await promise;
+}
+exports.init = init;
+function checkIgeParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 32) {
+        throw new TypeError("iv must be 32 bytes");
+    }
+}
+/**
+ * Performs IGE-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+function ige256Encrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(1024);
+    module_.ccall("ige256_encrypt", "void", ["array", "pointer", "number", "array", "array"], [data, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+    }
+}
+exports.ige256Encrypt = ige256Encrypt;
+/**
+ * Performs IGE-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 32-byte initialization vector
+ */
+function ige256Decrypt(data, key, iv) {
+    checkIgeParams(data, key, iv);
+    const out = module_._malloc(1024);
+    module_.ccall("ige256_decrypt", "void", ["array", "pointer", "number", "array", "array"], [data, out, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(out, out + data.length);
+    }
+    finally {
+        module_._free(out);
+    }
+}
+exports.ige256Decrypt = ige256Decrypt;
+function checkCtrParams(data, key, iv, state) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+    else if (state.length != 1) {
+        throw new TypeError("state must be 1 byte");
+    }
+}
+/**
+ * Performs CTR-256 encryption/decryption.
+ *
+ * @param data The data, larger than a byte
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ * @param state 1-byte state
+ */
+function ctr256(data, key, iv, state) {
+    checkCtrParams(data, key, iv, state);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    const ivp = module_._malloc(iv.length);
+    module_.HEAPU8.set(iv, ivp);
+    const statep = module_._malloc(state.length);
+    module_.HEAPU8.set(state, statep);
+    module_.ccall("ctr256", "void", ["pointer", "number", "array", "pointer", "pointer"], [datap, data.length, key, ivp, statep]);
+    data.set(module_.HEAPU8.slice(datap, datap + data.length));
+    iv.set(module_.HEAPU8.slice(ivp, ivp + iv.length));
+    state.set(module_.HEAPU8.slice(statep, statep + state.length));
+    module_._free(datap);
+    module_._free(ivp);
+    module_._free(statep);
+}
+exports.ctr256 = ctr256;
+function checkCbcParams(data, key, iv) {
+    if (data.length == 0) {
+        throw new TypeError("data must not be empty");
+    }
+    else if (data.length % 16 != 0) {
+        throw new TypeError("data must consist of a number of bytes that is divisible by 16");
+    }
+    else if (key.length != 32) {
+        throw new TypeError("key must be 32 bytes");
+    }
+    else if (iv.length != 16) {
+        throw new TypeError("iv must be 16 bytes");
+    }
+}
+/**
+ * Performs CBC-256 encryption.
+ *
+ * @param data The unencrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+function cbc256Encrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_encrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+exports.cbc256Encrypt = cbc256Encrypt;
+/**
+ * Performs CBC-256 decryption.
+ *
+ * @param data The encrypted data, larger than a byte, divisible by 16
+ * @param key 32-byte encryption key
+ * @param iv 16-byte initialization vector
+ */
+function cbc256Decrypt(data, key, iv) {
+    checkCbcParams(data, key, iv);
+    const datap = module_._malloc(data.length);
+    module_.HEAPU8.set(data, datap);
+    module_.ccall("cbc256_decrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    try {
+        return module_.HEAPU8.slice(datap, datap + data.length);
+    }
+    finally {
+        module_._free(datap);
+    }
+}
+exports.cbc256Decrypt = cbc256Decrypt;
+function factorize(pq) {
+    const pqp = module_._malloc(16);
+    module_.ccall("factorize", "void", ["number", "pointer"], [pq, pqp]);
+    try {
+        const pqp_ = module_.HEAP64.slice(pqp / 8, pqp / 8 + 2);
+        return [pqp_[0], pqp_[1]];
+    }
+    finally {
+        module_._free(pqp);
+    }
+}
+exports.factorize = factorize;