sroosh 1.0.0

package/crypto/Factorizator.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Factorizator = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+const Helpers_1 = require("../Helpers");
+class Factorizator {
+    /**
+     * Calculates the greatest common divisor
+     * @param a {BigInteger}
+     * @param b {BigInteger}
+     * @returns {BigInteger}
+     */
+    static gcd(a, b) {
+        while (b.neq(big_integer_1.default.zero)) {
+            const temp = b;
+            b = a.remainder(b);
+            a = temp;
+        }
+        return a;
+    }
+    /**
+     * Factorizes the given number and returns both the divisor and the number divided by the divisor
+     * @param pq {BigInteger}
+     * @returns {{p: *, q: *}}
+     */
+    static factorize(pq) {
+        if (pq.remainder(2).equals(big_integer_1.default.zero)) {
+            return { p: (0, big_integer_1.default)(2), q: pq.divide((0, big_integer_1.default)(2)) };
+        }
+        let y = big_integer_1.default.randBetween((0, big_integer_1.default)(1), pq.minus(1));
+        const c = big_integer_1.default.randBetween((0, big_integer_1.default)(1), pq.minus(1));
+        const m = big_integer_1.default.randBetween((0, big_integer_1.default)(1), pq.minus(1));
+        let g = big_integer_1.default.one;
+        let r = big_integer_1.default.one;
+        let q = big_integer_1.default.one;
+        let x = big_integer_1.default.zero;
+        let ys = big_integer_1.default.zero;
+        let k;
+        while (g.eq(big_integer_1.default.one)) {
+            x = y;
+            for (let i = 0; (0, big_integer_1.default)(i).lesser(r); i++) {
+                y = (0, Helpers_1.modExp)(y, (0, big_integer_1.default)(2), pq).add(c).remainder(pq);
+            }
+            k = big_integer_1.default.zero;
+            while (k.lesser(r) && g.eq(big_integer_1.default.one)) {
+                ys = y;
+                const condition = big_integer_1.default.min(m, r.minus(k));
+                for (let i = 0; (0, big_integer_1.default)(i).lesser(condition); i++) {
+                    y = (0, Helpers_1.modExp)(y, (0, big_integer_1.default)(2), pq).add(c).remainder(pq);
+                    q = q.multiply(x.minus(y).abs()).remainder(pq);
+                }
+                g = Factorizator.gcd(q, pq);
+                k = k.add(m);
+            }
+            r = r.multiply(2);
+        }
+        if (g.eq(pq)) {
+            while (true) {
+                ys = (0, Helpers_1.modExp)(ys, (0, big_integer_1.default)(2), pq).add(c).remainder(pq);
+                g = Factorizator.gcd(x.minus(ys).abs(), pq);
+                if (g.greater(1)) {
+                    break;
+                }
+            }
+        }
+        const p = g;
+        q = pq.divide(g);
+        return p < q ? { p: p, q: q } : { p: q, q: p };
+    }
+}
+exports.Factorizator = Factorizator;

package/crypto/IGE.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+declare class IGENEW {
+    private ige;
+    constructor(key: Buffer, iv: Buffer);
+    /**
+     * Decrypts the given text in 16-bytes blocks by using the given key and 32-bytes initialization vector
+     * @param cipherText {Buffer}
+     * @returns {Buffer}
+     */
+    decryptIge(cipherText: Buffer): Buffer;
+    /**
+     * Encrypts the given text in 16-bytes blocks by using the given key and 32-bytes initialization vector
+     * @param plainText {Buffer}
+     * @returns {Buffer}
+     */
+    encryptIge(plainText: Buffer): Buffer;
+}
+export { IGENEW as IGE };

package/crypto/IGE.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGE = void 0;
+const Helpers = require("../Helpers");
+const { IGE: aes_ige } = require("@cryptography/aes");
+class IGENEW {
+    constructor(key, iv) {
+        this.ige = new aes_ige(key, iv);
+    }
+    /**
+     * Decrypts the given text in 16-bytes blocks by using the given key and 32-bytes initialization vector
+     * @param cipherText {Buffer}
+     * @returns {Buffer}
+     */
+    decryptIge(cipherText) {
+        return Helpers.convertToLittle(this.ige.decrypt(cipherText));
+    }
+    /**
+     * Encrypts the given text in 16-bytes blocks by using the given key and 32-bytes initialization vector
+     * @param plainText {Buffer}
+     * @returns {Buffer}
+     */
+    encryptIge(plainText) {
+        const padding = plainText.length % 16;
+        if (padding) {
+            plainText = Buffer.concat([
+                plainText,
+                Helpers.generateRandomBytes(16 - padding),
+            ]);
+        }
+        return Helpers.convertToLittle(this.ige.encrypt(plainText));
+    }
+}
+exports.IGE = IGENEW;

package/crypto/RSA.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import bigInt from "big-integer";
+export declare const _serverKeys: Map<string, {
+    n: bigInt.BigInteger;
+    e: number;
+}>;
+/**
+ * Encrypts the given data known the fingerprint to be used
+ * in the way Telegram requires us to do so (sha1(data) + data + padding)
+
+ * @param fingerprint the fingerprint of the RSA key.
+ * @param data the data to be encrypted.
+ * @returns {Buffer|*|undefined} the cipher text, or undefined if no key matching this fingerprint is found.
+ */
+export declare function encrypt(fingerprint: bigInt.BigInteger, data: Buffer): Promise<Buffer | undefined>;

package/crypto/RSA.js

@@ -0,0 +1,150 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = exports._serverKeys = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+const Helpers_1 = require("../Helpers");
+const PUBLIC_KEYS = [
+    {
+        fingerprint: (0, big_integer_1.default)("1756106365847508527"),
+        n: (0, big_integer_1.default)("24238017039406324398818211100017460853877925248782649032256867755810335814127124174152552731142554114852422558645777814390854384939307234864895464642798398028371542228969164000877103469497598660814243455942166911962275149243241136966793567305207921915048350204489516378689905194216789741874810118898414872745651826381529051462943943060849600549855155618459538046759513047741178572508028156727115094924075836133814760736535296653732158626606889032969597095552163452422289022952141357954550600757285098604619618920582009763141301625135222696080861958446437367103385485660067248268161547714346218480166799291098838822637"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("4512654018935143700"),
+        n: (0, big_integer_1.default)("24235260037890616169120794235062262674316024975077366890198797443331519080732755901363433156102098672541115756594495998709831497291855317743857599933614215433431882467805644923653595607403240513727541136547826962095235110116337427731828103883948424780929997236931407307169894268539301307119160296066712383693459066029441762074173759747793039174943183613832584177865789542225605910018410709652462430479960297418110622242830949114847276874797307530921524192744012016471098946454164482843546804965228364603315089956692139144290446684470924997647106858968233924279740471552020606031234618000396222660365264833969144099689"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("3954552239731554950"),
+        n: (0, big_integer_1.default)("24232829137928731863019490002272733547385109287748297178609100006065549257095568082915937431578124587337794419409505050329102232313883718364639325401969651389116552838463132089986552293089568181366809408321934732862413729055496124940315094723812534661640494201559990530556774916900223297896209016669206232920888207341821205210891303083904139661142906408868611981611963687788770378695879011402303937435839797563703645760891960964101470680979117200293634538267916988134218179357404908420594084400131979794539094631619249407376814557856095132297201658918486640887798052272377986351953478094540165680281771116997441734993"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("3840879616129353640"),
+        n: (0, big_integer_1.default)("24226740003845387526122420383215813313160481817646534954349406594626036763275434691654700873685207371364562560617513084485551764162313690591806956872846659907830643797349274445997728236041847050770194661202868608462800289923910952988537320887544165103060997775840429356973390565265381070029205138105237970981099188549518140588436045472449701138095349921239316849430956077286762827767297232718282160587331191873355577824832392331680272547948467113172934998437902856416395533425838596802424433387992920842347995664806751296809332290342152475668988401357419279530258635231544972387436349151853117346156473906307508757549"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("9721673155303707927"),
+        n: (0, big_integer_1.default)("24235887198671065183055559947724015202901578705257391127883023207130325404209944274441623365774400996125245803826674984630558065530801346509332483039911631199004349799404280051072462526587571180814264659704919975908481860485392697091312975059521505252243307029981562770551539328732454274175686423286372017171706172687007694344562256482111767528076194851300510416590635106402450593729914970198599025438375131735218828188369140906636454128309358530468585125463089729781282854480794582223826120006365903044441770824989674440663577903688826372961995342818099867691669681672230707247497372041028959094232101600968274415909"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("7327245710266107682"),
+        n: (0, big_integer_1.default)("24233564129976052525074557234863243932690922138106909359656144523154213183753506814850645168001577563855229772321433282956411845640925035870968972803136480518327839574672220874857257522033398020724503795612522966253226642346178003829500572676012295974220897791590693412410598927265125769563882185124360261103470929664258060261189680335028461109077433213486615371932159709849345808113812001115072270346716870722377262463616658269378937324271848255503453424157667443329122247165267772229992577323167042062228644298199963610119085504374702555387623787457423479408655064120078431039033708876830736678360594495005894285717"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("7311641324696334512"),
+        n: (0, big_integer_1.default)("24238904092765623654541951735864997636805739769868168409716631959515469207569320832435968810337769651850580018414508646205665007373580374454395606146597849315923870670127753544137087350549900254610551324524604571915228715018530629778298064618268998531793173214036172363025839131060339130881375219446465668205779446789649992083429162676455112627392603665592101688014918149206881529578523272334726996711735101572984859875549951905127125799205155064098291930887529833481849200040487496164143132362127196384113142372423142258452585061291011491812576430380789840081128126636524048534242489396825475946269701146582317743657"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("5524002727329132702"),
+        n: (0, big_integer_1.default)("24240840390944090341507953931793624151763744285563544030910416784236727462750689550882282684085969155875993563675744852648552717349026668910077199849073601728876305909329013402215915886356001505563731538867739529640235766477773878514285912876193140368688382252273204355188089098846601780006831681303843231908846120924758803643829705110820216506673657502707864484421619874710577778393813357430704906944216680999917516195329215472962777640129203129770439225116577891002812853189041960585299399249968153372691725885820340316511845659627253451466115694977127425555862186933193218394320394258694625575382100116288975340549"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("2155561823286592012"),
+        n: (0, big_integer_1.default)("24243204744019316140571390393410731044654264209980898428670746497205291386024859137646251159342861816150128941773691765890192527564620428158169785622636505535629877349480617450560211048944399739063850448630948066199276397698436674230327767005624782137249362550473395158990527076392726209697596675639019343431160273964306938051977616487039715401404799862526727477302181083747478624994178928979351838016002623078026537816937662621346331619607922153654990755682564560671138040298018060956367906310050176108465773963874560935962712092372009916305687613610568043052253976511360748800839532555791190958981455525068313616897"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("17531275267172558227"),
+        n: (0, big_integer_1.default)("24255139658927753013873254536141189189753237402252128733006540963901927076142349649954801019467156677718322370092675980874397265945177264702598929380544295193481322378721816476070729371813229094364350010101862393838172088864447803332092418041246949084178401713364385838881375015827144945794095153786964846571030388355787508753531991993961555254969042717605460196000799545102877923469722288616794557923288888983011269037240565601793493311068493308734157084807580786404284886544532698648917545300042554928459645078414300497757390122490443598743777136771649253346883604382743910194553040289048690026107067641101240869757"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("4575657650171602427"),
+        n: (0, big_integer_1.default)("24241748716979944158438708449394223653204961060765827143973368617884492447942261505523443187257601236103340265615559639527180630229197439866502776378686835096407353804066949909701285818617975495760522238490671487712029011986651201719536090542896321467265696201328659954098773412180034421153101058632557542704289472001536987018842653632943335838465498174097963939308591427024890952308345708116210029583441063643004077552629178414709522805324640781966790694937052743127193386201247420273918072292131700727741792837690434676101793120971404158497279036295245865400265894452436582085456827818149587723815498705423505525321"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("3567622298816760148"),
+        n: (0, big_integer_1.default)("24241973069830180936382486136851951013243348105350204138487124818017867602625899293258552187838336184674670049713933766933757351489570820842327703265958170901615264973187032752096701011614110157776312764845302570082529385495470140920146051878730342948396344845297689539640313824769114338228755143118971304481173971615303964077469979652053857783729373752576433365489059477702349286208930722931204796741218051283105702556757466403365671339510414300696164894372274177945557949148910985421194213163965384331982024228279179527914200131998654289345727195757973563789660861631701724424526652398311923904246625005126377592521"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("17553063345690371958"),
+        n: (0, big_integer_1.default)("24241351281279299145481747591583493078714093870975713145334774261321717014781399628806087038848831852485223813136532926712665125270156627916952445277417726147982780684777659771520097728759904421321965854937862064740047454279621386406085143534690226076281213842173610596031643343879891078193115303418753930218318027953591820866890833986120632305938339616731461135194085454784667673649470129245909222026882631141387315757782391400515676373846987208768872585135598971809900399024770733365259205359339785306556181974113602739399615870858743653524190023863576735524226166101143210526674060026402436659365308688510078690497"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("9277528552786967144"),
+        n: (0, big_integer_1.default)("24238883792812457903440955355642945950073022904970495801657093251869089713665121911149481234050853934233122064092523442293485485973465562612462219587481815730600402639326960136165554757892118468323726552797797164131902401769109455064629623949487693529716691024261405998062219772670890185173102183412411788189060292277688538193979326171472099753319325396308639069346901555802056221461406051787468350371495259148993101781275112408866779921537695676863740570738579953904002087945727029190297738095608918499336688211985497328456484829874330588018880380000963974882409830117909102404397518375709893711959298913212944063661"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("6568519800617090630"),
+        n: (0, big_integer_1.default)("24239588619862180508360098040512418478680581611170711472883928025686825099356249917712225099148223711077059432200028063463093865372091311205580643550051338386984879877676235105123154065518600959875711395451795757738760134829594597167255271693432072928388818915612111091816614607170457231661478416252209722562831276455953742376708783408890398220602426478965073031487055861137035030458199714371038052587482387852918218274226889973351746476739523268586850465610743992484692267611070713846948961575290727414876842104679461061769756369084968039212031985243195756288727866220885995292271051896140306080831566727722276074957"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("15281512440970464298"),
+        n: (0, big_integer_1.default)("24239599512582931255427359431270572618952258131975769988260722303793575773752906274343700600720098035285579177975758854783208633709515855105374263407538462905252408613429494890312418721520791650769366216794922936974747169144475850347680874367281918740311749178059811810094869294916305229616949847003803916684366149987503343184025245931779539066699101382363380634723870546611475521905446162854714187876049892459528476639455612521723735146705760038501370073301822766125048910027686879641453113850638808677316725452385146298771974291225307327761780054966757171689178074696096619801471350533150098368772709207148837901569"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("5249484155803885630"),
+        n: (0, big_integer_1.default)("24241265362203342369326328988460290759229617577623644619423503233932740075020161659571459870131599238665537387406219165949998870768595835314138560518720219669643365406220763480511872529480745144790239904422851448607682345196590211016662588012961680376371675762676332978139225933779099960536287742756092033539932302005664752819588590041459954217936610254734136991222417370010309428640594262604322713225993786279478042930507895472883113560516617327048112388283614781108894590930969640925430277232319453256199767091017235183579120241841848123248729513184343705728200298718504847249596611130093167582769393799885361028241"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("13541485698777891424"),
+        n: (0, big_integer_1.default)("24250582346038918253489590685273447797501021440754250552376556841251766168493300467201436977700810867213865077002754295254311264997981306507395212023425442763995925057937373861855081818382878597813104903647701486401235514293882661190390724306994977405565333072540104439523086038432800600883214234200236263214845445582364913787344216841610255185049453059347714444482989937073942074055145452916055812809467822364750111177789684519275729574001771486570693691791685231682148674414389652792950646465738793767111954048363986885331827825877145559966247324980948121305820656101676302232547121578841113489085078177977779644273"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("16862300725120269413"),
+        n: (0, big_integer_1.default)("24254000742908910780642772836620313045262355961163729937569619383555249902029716060200419148391019170804222412071963596191785861586891063699072641162488871066133046961090009396955121728733384027955976513502449787476821410788951310882648123274289437430318341855536075267235356097809280385965583038417386084366145339901748119758697655135929934549969707460599883140539174983072516221417031945054555985803873960199525313057600306925514544833040037018227697686306101849187175034825584965708811367071337597817211252921279005367930151150461576976714469449048972877200165293128214220683948771740718174833101709208764642734009"),
+        e: 65537,
+    },
+    {
+        fingerprint: (0, big_integer_1.default)("146161090623767708"),
+        n: (0, big_integer_1.default)("24253495355592939862541792106837927970578028684159052648663928248811410107333457728279277109502147340136333426729884744926183857264572402670419957082851015100418465126428222680133281570470371040523800642216862572710828580502430077960118583163279583538688255309017584970719200470208489986071618868024733969564549249389837986957516912955145904703360486166231033108413849041302009270425608550404235410771038637642469917472911594357670299410706994996555343504517052658790568611125226416060186111837634873507795341827902708071697966649511858963499400578689407839770254246385600914558793037831000053896621164798032464177741"),
+        e: 65537,
+    },
+];
+exports._serverKeys = new Map();
+PUBLIC_KEYS.forEach((_a) => {
+    var { fingerprint } = _a, keyInfo = __rest(_a, ["fingerprint"]);
+    exports._serverKeys.set(fingerprint.toString(), keyInfo);
+});
+/**
+ * Encrypts the given data known the fingerprint to be used
+ * in the way Telegram requires us to do so (sha1(data) + data + padding)
+
+ * @param fingerprint the fingerprint of the RSA key.
+ * @param data the data to be encrypted.
+ * @returns {Buffer|*|undefined} the cipher text, or undefined if no key matching this fingerprint is found.
+ */
+async function encrypt(fingerprint, data) {
+    const key = exports._serverKeys.get(fingerprint.toString());
+    if (!key) {
+        return undefined;
+    }
+    // len(sha1.digest) is always 20, so we're left with 255 - 20 - x padding
+    const rand = (0, Helpers_1.generateRandomBytes)(235 - data.length);
+    const toEncrypt = Buffer.concat([await (0, Helpers_1.sha1)(data), data, rand]);
+    // rsa module rsa.encrypt adds 11 bits for padding which we don't want
+    // rsa module uses rsa.transform.bytes2int(to_encrypt), easier way:
+    const payload = (0, Helpers_1.readBigIntFromBuffer)(toEncrypt, false);
+    const encrypted = (0, Helpers_1.modExp)(payload, (0, big_integer_1.default)(key.e), key.n);
+    // rsa module uses transform.int2bytes(encrypted, keylength), easier:
+    return (0, Helpers_1.readBufferFromBigInt)(encrypted, 256, false);
+}
+exports.encrypt = encrypt;

package/crypto/converters.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Uint32Array -> ArrayBuffer (low-endian os)
+ */
+export declare function i2abLow(buf: Uint32Array): ArrayBuffer;
+/**
+ * Uint32Array -> ArrayBuffer (big-endian os)
+ */
+export declare function i2abBig(buf: Uint32Array): ArrayBuffer;
+/**
+ * ArrayBuffer -> Uint32Array (low-endian os)
+ */
+export declare function ab2iLow(ab: ArrayBuffer | SharedArrayBuffer | Uint8Array): Uint32Array;
+/**
+ * ArrayBuffer -> Uint32Array (big-endian os)
+ */
+export declare function ab2iBig(ab: ArrayBuffer | SharedArrayBuffer | Uint8Array): Uint32Array;
+export declare const isBigEndian: boolean;
+export declare const i2ab: typeof i2abBig;
+export declare const ab2i: typeof ab2iBig;

package/crypto/converters.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ab2i = exports.i2ab = exports.isBigEndian = exports.ab2iBig = exports.ab2iLow = exports.i2abBig = exports.i2abLow = void 0;
+/**
+ * Uint32Array -> ArrayBuffer (low-endian os)
+ */
+function i2abLow(buf) {
+    const uint8 = new Uint8Array(buf.length * 4);
+    let i = 0;
+    for (let j = 0; j < buf.length; j++) {
+        const int = buf[j];
+        uint8[i++] = int >>> 24;
+        uint8[i++] = (int >> 16) & 0xff;
+        uint8[i++] = (int >> 8) & 0xff;
+        uint8[i++] = int & 0xff;
+    }
+    return uint8.buffer;
+}
+exports.i2abLow = i2abLow;
+/**
+ * Uint32Array -> ArrayBuffer (big-endian os)
+ */
+function i2abBig(buf) {
+    return buf.buffer;
+}
+exports.i2abBig = i2abBig;
+/**
+ * ArrayBuffer -> Uint32Array (low-endian os)
+ */
+function ab2iLow(ab) {
+    const uint8 = new Uint8Array(ab);
+    const buf = new Uint32Array(uint8.length / 4);
+    for (let i = 0; i < uint8.length; i += 4) {
+        buf[i / 4] =
+            (uint8[i] << 24) ^
+                (uint8[i + 1] << 16) ^
+                (uint8[i + 2] << 8) ^
+                uint8[i + 3];
+    }
+    return buf;
+}
+exports.ab2iLow = ab2iLow;
+/**
+ * ArrayBuffer -> Uint32Array (big-endian os)
+ */
+function ab2iBig(ab) {
+    return new Uint32Array(ab);
+}
+exports.ab2iBig = ab2iBig;
+exports.isBigEndian = new Uint8Array(new Uint32Array([0x01020304]))[0] === 0x01;
+exports.i2ab = exports.isBigEndian ? i2abBig : i2abLow;
+exports.ab2i = exports.isBigEndian ? ab2iBig : ab2iLow;

package/crypto/crypto.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+export declare class Counter {
+    _counter: Buffer;
+    constructor(initialValue: any);
+    increment(): void;
+}
+export declare class CTR {
+    private _counter;
+    private _remainingCounter?;
+    private _remainingCounterIndex;
+    private _aes;
+    constructor(key: Buffer, counter: any);
+    update(plainText: any): Buffer;
+    encrypt(plainText: any): Buffer;
+}
+export declare function createDecipheriv(algorithm: string, key: Buffer, iv: Buffer): CTR;
+export declare function createCipheriv(algorithm: string, key: Buffer, iv: Buffer): CTR;
+export declare function randomBytes(count: number): Uint8Array;
+export declare class Hash {
+    private readonly algorithm;
+    private data?;
+    constructor(algorithm: string);
+    update(data: Buffer): void;
+    digest(): Promise<Buffer>;
+}
+export declare function pbkdf2Sync(password: any, salt: any, iterations: any, ...args: any): Promise<Buffer>;
+export declare function createHash(algorithm: string): Hash;

package/crypto/crypto.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHash = exports.pbkdf2Sync = exports.Hash = exports.randomBytes = exports.createCipheriv = exports.createDecipheriv = exports.CTR = exports.Counter = void 0;
+const aes_1 = __importDefault(require("@cryptography/aes"));
+const converters_1 = require("./converters");
+const words_1 = require("./words");
+class Counter {
+    constructor(initialValue) {
+        this._counter = Buffer.from(initialValue);
+    }
+    increment() {
+        for (let i = 15; i >= 0; i--) {
+            if (this._counter[i] === 255) {
+                this._counter[i] = 0;
+            }
+            else {
+                this._counter[i]++;
+                break;
+            }
+        }
+    }
+}
+exports.Counter = Counter;
+class CTR {
+    constructor(key, counter) {
+        if (!(counter instanceof Counter)) {
+            counter = new Counter(counter);
+        }
+        this._counter = counter;
+        this._remainingCounter = undefined;
+        this._remainingCounterIndex = 16;
+        this._aes = new aes_1.default((0, words_1.getWords)(key));
+    }
+    update(plainText) {
+        return this.encrypt(plainText);
+    }
+    encrypt(plainText) {
+        const encrypted = Buffer.from(plainText);
+        for (let i = 0; i < encrypted.length; i++) {
+            if (this._remainingCounterIndex === 16) {
+                this._remainingCounter = Buffer.from((0, converters_1.i2ab)(this._aes.encrypt((0, converters_1.ab2i)(this._counter._counter))));
+                this._remainingCounterIndex = 0;
+                this._counter.increment();
+            }
+            if (this._remainingCounter) {
+                encrypted[i] ^=
+                    this._remainingCounter[this._remainingCounterIndex++];
+            }
+        }
+        return encrypted;
+    }
+}
+exports.CTR = CTR;
+// endregion
+function createDecipheriv(algorithm, key, iv) {
+    if (algorithm.includes("ECB")) {
+        throw new Error("Not supported");
+    }
+    else {
+        return new CTR(key, iv);
+    }
+}
+exports.createDecipheriv = createDecipheriv;
+function createCipheriv(algorithm, key, iv) {
+    if (algorithm.includes("ECB")) {
+        throw new Error("Not supported");
+    }
+    else {
+        return new CTR(key, iv);
+    }
+}
+exports.createCipheriv = createCipheriv;
+function randomBytes(count) {
+    const bytes = new Uint8Array(count);
+    crypto.getRandomValues(bytes);
+    return bytes;
+}
+exports.randomBytes = randomBytes;
+class Hash {
+    constructor(algorithm) {
+        this.algorithm = algorithm;
+    }
+    update(data) {
+        //We shouldn't be needing new Uint8Array but it doesn't
+        //work without it
+        this.data = new Uint8Array(data);
+    }
+    async digest() {
+        if (this.data) {
+            if (this.algorithm === "sha1") {
+                return Buffer.from(await self.crypto.subtle.digest("SHA-1", this.data));
+            }
+            else if (this.algorithm === "sha256") {
+                return Buffer.from(await self.crypto.subtle.digest("SHA-256", this.data));
+            }
+        }
+        return Buffer.alloc(0);
+    }
+}
+exports.Hash = Hash;
+async function pbkdf2Sync(password, salt, iterations, ...args) {
+    const passwordKey = await crypto.subtle.importKey("raw", password, { name: "PBKDF2" }, false, ["deriveBits"]);
+    return Buffer.from(await crypto.subtle.deriveBits({
+        name: "PBKDF2",
+        hash: "SHA-512",
+        salt,
+        iterations,
+    }, passwordKey, 512));
+}
+exports.pbkdf2Sync = pbkdf2Sync;
+function createHash(algorithm) {
+    return new Hash(algorithm);
+}
+exports.createHash = createHash;

package/crypto/words.d.ts

@@ -0,0 +1,6 @@
+export declare function s2i(str: string, pos: number): number;
+/**
+ * Helper function for transforming string key to Uint32Array
+ */
+export declare function getWords(key: string | Uint8Array | Uint32Array): Uint32Array;
+export declare function xor(left: Uint32Array, right: Uint32Array, to?: Uint32Array): void;

package/crypto/words.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Imported from https://github.com/spalt08/cryptography/blob/master/packages/aes/src/utils/words.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xor = exports.getWords = exports.s2i = void 0;
+function s2i(str, pos) {
+    return ((str.charCodeAt(pos) << 24) ^
+        (str.charCodeAt(pos + 1) << 16) ^
+        (str.charCodeAt(pos + 2) << 8) ^
+        str.charCodeAt(pos + 3));
+}
+exports.s2i = s2i;
+/**
+ * Helper function for transforming string key to Uint32Array
+ */
+function getWords(key) {
+    if (key instanceof Uint32Array) {
+        return key;
+    }
+    if (typeof key === "string") {
+        if (key.length % 4 !== 0)
+            for (let i = key.length % 4; i <= 4; i++)
+                key += "\0x00";
+        const buf = new Uint32Array(key.length / 4);
+        for (let i = 0; i < key.length; i += 4)
+            buf[i / 4] = s2i(key, i);
+        return buf;
+    }
+    if (key instanceof Uint8Array) {
+        const buf = new Uint32Array(key.length / 4);
+        for (let i = 0; i < key.length; i += 4) {
+            buf[i / 4] =
+                (key[i] << 24) ^
+                    (key[i + 1] << 16) ^
+                    (key[i + 2] << 8) ^
+                    key[i + 3];
+        }
+        return buf;
+    }
+    throw new Error("Unable to create 32-bit words");
+}
+exports.getWords = getWords;
+function xor(left, right, to = left) {
+    for (let i = 0; i < left.length; i++)
+        to[i] = left[i] ^ right[i];
+}
+exports.xor = xor;

package/entityCache.d.ts

@@ -0,0 +1,7 @@
+import bigInt from "big-integer";
+export declare class EntityCache {
+    private cacheMap;
+    constructor();
+    add(entities: any): void;
+    get(item: bigInt.BigInteger | string | undefined): any;
+}

package/entityCache.js

@@ -0,0 +1,79 @@
+"use strict";
+// Which updates have the following fields?
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityCache = void 0;
+const Utils_1 = require("./Utils");
+const Helpers_1 = require("./Helpers");
+const tl_1 = require("./tl");
+const big_integer_1 = __importDefault(require("big-integer"));
+class EntityCache {
+    constructor() {
+        this.cacheMap = new Map();
+    }
+    add(entities) {
+        const temp = [];
+        if (!(0, Helpers_1.isArrayLike)(entities)) {
+            if (entities != undefined) {
+                if (typeof entities == "object") {
+                    if ("chats" in entities) {
+                        temp.push(...entities.chats);
+                    }
+                    if ("users" in entities) {
+                        temp.push(...entities.users);
+                    }
+                    if ("user" in entities) {
+                        temp.push(entities.user);
+                    }
+                }
+            }
+            if (temp.length) {
+                entities = temp;
+            }
+            else {
+                return;
+            }
+        }
+        for (const entity of entities) {
+            try {
+                const pid = (0, Utils_1.getPeerId)(entity);
+                if (!this.cacheMap.has(pid.toString())) {
+                    this.cacheMap.set(pid.toString(), (0, Utils_1.getInputPeer)(entity));
+                }
+            }
+            catch (e) { }
+        }
+    }
+    get(item) {
+        if (item == undefined) {
+            throw new Error("No cached entity for the given key");
+        }
+        item = (0, Helpers_1.returnBigInt)(item);
+        if (item.lesser(big_integer_1.default.zero)) {
+            let res;
+            try {
+                res = this.cacheMap.get((0, Utils_1.getPeerId)(item).toString());
+                if (res) {
+                    return res;
+                }
+            }
+            catch (e) {
+                throw new Error("Invalid key will not have entity");
+            }
+        }
+        for (const cls of [tl_1.Api.PeerUser, tl_1.Api.PeerChat, tl_1.Api.PeerChannel]) {
+            const result = this.cacheMap.get((0, Utils_1.getPeerId)(new cls({
+                userId: item,
+                chatId: item,
+                channelId: item,
+            })).toString());
+            if (result) {
+                return result;
+            }
+        }
+        throw new Error("No cached entity for the given key");
+    }
+}
+exports.EntityCache = EntityCache;