@mtkruto/node 0.0.61 → 0.0.63

package/script/utilities/1_password.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPassword = exports.pad = exports.isGoodModExpFirst = exports.ph2 = exports.pbkdf2 = exports.ph1 = exports.sh = exports.h = exports.isSafePrime = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const types = __importStar(require("../tl/2_types.js"));
+const _0_buffer_js_1 = require("./0_buffer.js");
+const _0_hash_js_1 = require("./0_hash.js");
+const _0_bigint_js_1 = require("./0_bigint.js");
+function isSafePrime(primeBytes, g) {
+    // deno-fmt-ignore
+    const goodPrime = new Uint8Array([
+        0xC7, 0x1C, 0xAE, 0xB9, 0xC6, 0xB1, 0xC9, 0x04, 0x8E, 0x6C, 0x52, 0x2F,
+        0x70, 0xF1, 0x3F, 0x73, 0x98, 0x0D, 0x40, 0x23, 0x8E, 0x3E, 0x21, 0xC1,
+        0x49, 0x34, 0xD0, 0x37, 0x56, 0x3D, 0x93, 0x0F, 0x48, 0x19, 0x8A, 0x0A,
+        0xA7, 0xC1, 0x40, 0x58, 0x22, 0x94, 0x93, 0xD2, 0x25, 0x30, 0xF4, 0xDB,
+        0xFA, 0x33, 0x6F, 0x6E, 0x0A, 0xC9, 0x25, 0x13, 0x95, 0x43, 0xAE, 0xD4,
+        0x4C, 0xCE, 0x7C, 0x37, 0x20, 0xFD, 0x51, 0xF6, 0x94, 0x58, 0x70, 0x5A,
+        0xC6, 0x8C, 0xD4, 0xFE, 0x6B, 0x6B, 0x13, 0xAB, 0xDC, 0x97, 0x46, 0x51,
+        0x29, 0x69, 0x32, 0x84, 0x54, 0xF1, 0x8F, 0xAF, 0x8C, 0x59, 0x5F, 0x64,
+        0x24, 0x77, 0xFE, 0x96, 0xBB, 0x2A, 0x94, 0x1D, 0x5B, 0xCD, 0x1D, 0x4A,
+        0xC8, 0xCC, 0x49, 0x88, 0x07, 0x08, 0xFA, 0x9B, 0x37, 0x8E, 0x3C, 0x4F,
+        0x3A, 0x90, 0x60, 0xBE, 0xE6, 0x7C, 0xF9, 0xA4, 0xA4, 0xA6, 0x95, 0x81,
+        0x10, 0x51, 0x90, 0x7E, 0x16, 0x27, 0x53, 0xB5, 0x6B, 0x0F, 0x6B, 0x41,
+        0x0D, 0xBA, 0x74, 0xD8, 0xA8, 0x4B, 0x2A, 0x14, 0xB3, 0x14, 0x4E, 0x0E,
+        0xF1, 0x28, 0x47, 0x54, 0xFD, 0x17, 0xED, 0x95, 0x0D, 0x59, 0x65, 0xB4,
+        0xB9, 0xDD, 0x46, 0x58, 0x2D, 0xB1, 0x17, 0x8D, 0x16, 0x9C, 0x6B, 0xC4,
+        0x65, 0xB0, 0xD6, 0xFF, 0x9C, 0xA3, 0x92, 0x8F, 0xEF, 0x5B, 0x9A, 0xE4,
+        0xE4, 0x18, 0xFC, 0x15, 0xE8, 0x3E, 0xBE, 0xA0, 0xF8, 0x7F, 0xA9, 0xFF,
+        0x5E, 0xED, 0x70, 0x05, 0x0D, 0xED, 0x28, 0x49, 0xF4, 0x7B, 0xF9, 0x59,
+        0xD9, 0x56, 0x85, 0x0C, 0xE9, 0x29, 0x85, 0x1F, 0x0D, 0x81, 0x15, 0xF6,
+        0x35, 0xB1, 0x05, 0xEE, 0x2E, 0x4E, 0x15, 0xD0, 0x4B, 0x24, 0x54, 0xBF,
+        0x6F, 0x4F, 0xAD, 0xF0, 0x34, 0xB1, 0x04, 0x03, 0x11, 0x9C, 0xD8, 0xE3,
+        0xB9, 0x2F, 0xCC, 0x5B,
+    ]);
+    if (goodPrime.every((v, i) => v == primeBytes[i])) {
+        if ([3, 4, 5, 7].includes(g)) { // It's good
+            return true;
+        }
+    }
+    return false;
+}
+exports.isSafePrime = isSafePrime;
+// H(data) := sha256(data)
+exports.h = _0_hash_js_1.sha256;
+// SH(data, salt) := H(salt | data | salt)
+const sh = (data, salt) => (0, exports.h)((0, _0_buffer_js_1.concat)(salt, data, salt));
+exports.sh = sh;
+// PH1(password, salt1, salt2) := SH(SH(password, salt1), salt2)
+const ph1 = async (password, salt1, salt2) => await (0, exports.sh)(await (0, exports.sh)(password, salt1), salt2);
+exports.ph1 = ph1;
+async function pbkdf2(password, salt, iterations) {
+    const key = await dntShim.dntGlobalThis.crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits"]);
+    const buffer = await dntShim.dntGlobalThis.crypto.subtle.deriveBits({ name: "PBKDF2", salt, iterations, hash: "SHA-512" }, key, 512);
+    return new Uint8Array(buffer);
+}
+exports.pbkdf2 = pbkdf2;
+// PH2(password, salt1, salt2) := SH(pbkdf2(sha512, PH1(password, salt1, salt2), salt1, 100000), salt2)
+const ph2 = async (password, salt1, salt2) => await (0, exports.sh)(await pbkdf2(await (0, exports.ph1)(password, salt1, salt2), salt1, 100000), salt2);
+exports.ph2 = ph2;
+function isGoodModExpFirst(modexp, prime) {
+    const diff = prime - modexp;
+    const minDiffBitsCount = 2048 - 64;
+    const maxModExpSize = 256;
+    return !(diff < 0n ||
+        diff.toString(2).length < minDiffBitsCount ||
+        modexp.toString(2).length < minDiffBitsCount ||
+        Math.floor((modexp.toString(2).length + 7) / 8) > maxModExpSize);
+}
+exports.isGoodModExpFirst = isGoodModExpFirst;
+function pad(bigint) {
+    if (typeof bigint === "number") {
+        bigint = BigInt(bigint);
+    }
+    if (typeof bigint === "bigint") {
+        return (0, _0_buffer_js_1.bufferFromBigInt)(bigint, 256, false);
+    }
+    else {
+        return (0, _0_buffer_js_1.concat)(new Uint8Array(256 - bigint.length), bigint);
+    }
+}
+exports.pad = pad;
+async function checkPassword(password, ap) {
+    const algo = ap.currentAlgo;
+    if (!(algo instanceof
+        types.PasswordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow)) {
+        throw new Error("Unexpected algorithm");
+    }
+    // g := algo.g
+    const g = algo.g;
+    // p := algo.p
+    const p = (0, _0_bigint_js_1.bigIntFromBuffer)(algo.p, false);
+    if (!isSafePrime(algo.p, g)) {
+        throw new Error("Got unsafe prime");
+    }
+    const srpB = ap.srpB;
+    const srpId = ap.srpId;
+    {
+        if (!srpB) {
+            throw new Error("srbB is not set");
+        }
+        if (!srpId) {
+            throw new Error("srpId is not set");
+        }
+    }
+    // salt1 := algo.salt1
+    const salt1 = algo.salt1;
+    // salt2 := algo.salt2
+    const salt2 = algo.salt2;
+    // g_b := srp_B
+    const gB = (0, _0_bigint_js_1.bigIntFromBuffer)(srpB, false);
+    // k := H(p | g)
+    const k = (0, _0_bigint_js_1.bigIntFromBuffer)(await (0, exports.h)((0, _0_buffer_js_1.concat)(pad(p), pad(g))), false);
+    let u = 0n;
+    let a = 0n;
+    let gA = 0n;
+    for (let i = 0; i < 1000; i++) {
+        a = (0, _0_bigint_js_1.getRandomBigInt)(256, false);
+        // g_a := pow(g, a) mod p
+        gA = (0, _0_bigint_js_1.modExp)(BigInt(g), a, p);
+        if (isGoodModExpFirst(gA, p)) {
+            u = (0, _0_bigint_js_1.bigIntFromBuffer)(await (0, _0_hash_js_1.sha256)((0, _0_buffer_js_1.concat)(pad(gA), pad(gB))), false);
+            if (u > 0n) {
+                break;
+            }
+        }
+    }
+    if (!a || !u || !gA) {
+        throw new Error();
+    }
+    // x := PH2(password, salt1, salt2)
+    const x = (0, _0_bigint_js_1.bigIntFromBuffer)(await (0, exports.ph2)(password, salt1, salt2), false);
+    // v := pow(g, x) mod p
+    const v = (0, _0_bigint_js_1.modExp)(BigInt(g), x, p);
+    // k_v := (k * v) mod p
+    const kV = (0, _0_bigint_js_1.mod)(k * v, p);
+    // t := (g_b - k_v) mod p
+    const t = (0, _0_bigint_js_1.mod)(gB - kV, p);
+    // s_a := pow(t, a + u * x) mod p
+    const sA = (0, _0_bigint_js_1.modExp)(t, a + u * x, p);
+    // k_a := H(s_a)
+    const kA = await (0, exports.h)(pad(sA));
+    // M1 := H(H(p) xor H(g) | H(salt1) | H(salt2) | g_a | g_b | k_a)
+    const hG = await (0, exports.h)(pad(g));
+    const m1 = await (0, exports.h)((0, _0_buffer_js_1.concat)((await (0, exports.h)(pad(p))).map((v, i) => v ^ hG[i]), await (0, exports.h)(salt1), await (0, exports.h)(salt2), pad(gA), pad(gB), kA));
+    return new types.InputCheckPasswordSRP({
+        srpId: srpId,
+        A: pad(gA),
+        M1: m1,
+    });
+}
+exports.checkPassword = checkPassword;

package/types/deps/deno.land/x/tgcrypto@0.1.3/tgcrypto.d.ts

@@ -0,0 +1,2 @@
+export default Module;
+declare function Module(Module?: {}): any;

package/types/deps.d.ts

@@ -1,4 +1,4 @@
 export * from "./deps/deno.land/std@0.186.0/testing/asserts.js";
-export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.1.1/mod.js";
+export { ctr256Decrypt, ctr256Encrypt, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.1.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/master/gzip/gzip.js";
 export { Mutex } from "async-mutex";

package/types/mod.d.ts

@@ -1,4 +1,15 @@
+import { checkPassword } from "./utilities/1_password.js";
+import { getRandomId } from "./utilities/0_bigint.js";
+export declare const utils: {
+    checkPassword: typeof checkPassword;
+    getRandomId: typeof getRandomId;
+};
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
-export { ClientPlain } from "./client/client_plain.js";
-export { Client } from "./client/client.js";
+export * from "./client/client_plain.js";
+export * from "./client/client.js";
+export * from "./transport/transport_abridged.js";
+export * from "./transport/transport_intermediate.js";
+export * from "./transport/transport.js";
+export * from "./transport/transport_provider.js";
+export * from "./connection/connection.js";

package/types/transport/transport_abridged.d.ts

@@ -0,0 +1,11 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "./transport.js";
+export declare class TransportAbridged extends Transport implements Transport {
+    private readonly connection;
+    private readonly obfuscated;
+    constructor(connection: Connection, obfuscated?: boolean);
+    initialize(): Promise<void>;
+    receive(): Promise<Uint8Array>;
+    send(buffer: Uint8Array): Promise<void>;
+    deinitialize(): void;
+}

package/types/utilities/0_bigint.d.ts

@@ -2,3 +2,4 @@ export declare function modExp(a: bigint, b: bigint, n: bigint): bigint;
 export declare function mod(n: bigint, m: bigint): bigint;
 export declare function bigIntFromBuffer(buffer: Uint8Array, little?: boolean, signed?: boolean): bigint;
 export declare function getRandomBigInt(byteLength: number, little?: boolean, signed?: boolean): bigint;
+export declare function getRandomId(): bigint;

package/types/utilities/1_password.d.ts

@@ -0,0 +1,11 @@
+import * as types from "../tl/2_types.js";
+import { sha256 } from "./0_hash.js";
+export declare function isSafePrime(primeBytes: Uint8Array, g: number): boolean;
+export declare const h: typeof sha256;
+export declare const sh: (data: Uint8Array, salt: Uint8Array) => Promise<Uint8Array>;
+export declare const ph1: (password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array) => Promise<Uint8Array>;
+export declare function pbkdf2(password: Uint8Array, salt: Uint8Array, iterations: number): Promise<Uint8Array>;
+export declare const ph2: (password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array) => Promise<Uint8Array>;
+export declare function isGoodModExpFirst(modexp: bigint, prime: bigint): boolean;
+export declare function pad(bigint: number | bigint | Uint8Array): Uint8Array;
+export declare function checkPassword(password: Uint8Array, ap: types.AccountPassword): Promise<types.InputCheckPasswordSRP>;

package/types/deps/deno.land/x/tgcrypto@0.1.1/tgcrypto.d.ts

@@ -1,2 +0,0 @@
-export default Module;
-declare function Module(Module?: {}): Promise<any>;