ccxt 4.2.11 → 4.2.13

package/dist/cjs/js/src/static_dependencies/jsencrypt/lib/jsbn/prng4.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// prng4.js - uses Arcfour as a PRNG
+class Arcfour {
+    constructor() {
+        this.i = 0;
+        this.j = 0;
+        this.S = [];
+    }
+    // Arcfour.prototype.init = ARC4init;
+    // Initialize arcfour context from key, an array of ints, each from [0..255]
+    init(key) {
+        let i;
+        let j;
+        let t;
+        for (i = 0; i < 256; ++i) {
+            this.S[i] = i;
+        }
+        j = 0;
+        for (i = 0; i < 256; ++i) {
+            j = (j + this.S[i] + key[i % key.length]) & 255;
+            t = this.S[i];
+            this.S[i] = this.S[j];
+            this.S[j] = t;
+        }
+        this.i = 0;
+        this.j = 0;
+    }
+    // Arcfour.prototype.next = ARC4next;
+    next() {
+        let t;
+        this.i = (this.i + 1) & 255;
+        this.j = (this.j + this.S[this.i]) & 255;
+        t = this.S[this.i];
+        this.S[this.i] = this.S[this.j];
+        this.S[this.j] = t;
+        return this.S[(t + this.S[this.i]) & 255];
+    }
+}
+// Plug in your RNG constructor here
+function prng_newstate() {
+    return new Arcfour();
+}
+// Pool size must be a multiple of 4 and greater than 32.
+// An array of bytes the size of the pool will be passed to init()
+let rng_psize = 256;
+
+exports.Arcfour = Arcfour;
+exports.prng_newstate = prng_newstate;
+exports.rng_psize = rng_psize;

package/dist/cjs/js/src/static_dependencies/jsencrypt/lib/jsbn/rng.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var prng4 = require('./prng4.js');
+
+// Random number generator - requires a PRNG backend, e.g. prng4.js
+let rng_state;
+let rng_pool = null;
+let rng_pptr;
+// Initialize the pool with junk if needed.
+if (rng_pool == null) {
+    rng_pool = [];
+    rng_pptr = 0;
+    let t;
+    if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
+        // Extract entropy (2048 bits) from RNG if available
+        const z = new Uint32Array(256);
+        window.crypto.getRandomValues(z);
+        for (t = 0; t < z.length; ++t) {
+            rng_pool[rng_pptr++] = z[t] & 255;
+        }
+    }
+    // Use mouse events for entropy, if we do not have enough entropy by the time
+    // we need it, entropy will be generated by Math.random.
+    var count = 0;
+    const onMouseMoveListener = function (ev) {
+        count = count || 0;
+        if (count >= 256 || rng_pptr >= prng4.rng_psize) {
+            if (window.removeEventListener) {
+                window.removeEventListener("mousemove", onMouseMoveListener, false);
+            }
+            else if (window.detachEvent) {
+                window.detachEvent("onmousemove", onMouseMoveListener);
+            }
+            return;
+        }
+        try {
+            const mouseCoordinates = ev.x + ev.y;
+            rng_pool[rng_pptr++] = mouseCoordinates & 255;
+            count += 1;
+        }
+        catch (e) {
+            // Sometimes Firefox will deny permission to access event properties for some reason. Ignore.
+        }
+    };
+    if (typeof window !== 'undefined') {
+        if (window.addEventListener) {
+            window.addEventListener("mousemove", onMouseMoveListener, false);
+        }
+        else if (window.attachEvent) {
+            window.attachEvent("onmousemove", onMouseMoveListener);
+        }
+    }
+}
+function rng_get_byte() {
+    if (rng_state == null) {
+        rng_state = prng4.prng_newstate();
+        // At this point, we may not have collected enough entropy.  If not, fall back to Math.random
+        while (rng_pptr < prng4.rng_psize) {
+            const random = Math.floor(65536 * Math.random());
+            rng_pool[rng_pptr++] = random & 255;
+        }
+        rng_state.init(rng_pool);
+        for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
+            rng_pool[rng_pptr] = 0;
+        }
+        rng_pptr = 0;
+    }
+    // TODO: allow reseeding after first request
+    return rng_state.next();
+}
+class SecureRandom {
+    nextBytes(ba) {
+        for (let i = 0; i < ba.length; ++i) {
+            ba[i] = rng_get_byte();
+        }
+    }
+}
+
+exports.SecureRandom = SecureRandom;

package/dist/cjs/js/src/static_dependencies/jsencrypt/lib/jsbn/rsa.js

@@ -0,0 +1,376 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsbn = require('./jsbn.js');
+var rng = require('./rng.js');
+
+// Depends on jsbn.js and rng.js
+// function linebrk(s,n) {
+//   var ret = "";
+//   var i = 0;
+//   while(i + n < s.length) {
+//     ret += s.substring(i,i+n) + "\n";
+//     i += n;
+//   }
+//   return ret + s.substring(i,s.length);
+// }
+// function byte2Hex(b) {
+//   if(b < 0x10)
+//     return "0" + b.toString(16);
+//   else
+//     return b.toString(16);
+// }
+function pkcs1pad1(s, n) {
+    if (n < s.length + 22) {
+        console.error("Message too long for RSA");
+        return null;
+    }
+    const len = n - s.length - 6;
+    let filler = "";
+    for (let f = 0; f < len; f += 2) {
+        filler += "ff";
+    }
+    const m = "0001" + filler + "00" + s;
+    return jsbn.parseBigInt(m, 16);
+}
+// PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
+function pkcs1pad2(s, n) {
+    if (n < s.length + 11) { // TODO: fix for utf-8
+        console.error("Message too long for RSA");
+        return null;
+    }
+    const ba = [];
+    let i = s.length - 1;
+    while (i >= 0 && n > 0) {
+        const c = s.charCodeAt(i--);
+        if (c < 128) { // encode using utf-8
+            ba[--n] = c;
+        }
+        else if ((c > 127) && (c < 2048)) {
+            ba[--n] = (c & 63) | 128;
+            ba[--n] = (c >> 6) | 192;
+        }
+        else {
+            ba[--n] = (c & 63) | 128;
+            ba[--n] = ((c >> 6) & 63) | 128;
+            ba[--n] = (c >> 12) | 224;
+        }
+    }
+    ba[--n] = 0;
+    const rng$1 = new rng.SecureRandom();
+    const x = [];
+    while (n > 2) { // random non-zero pad
+        x[0] = 0;
+        while (x[0] == 0) {
+            rng$1.nextBytes(x);
+        }
+        ba[--n] = x[0];
+    }
+    ba[--n] = 2;
+    ba[--n] = 0;
+    return new jsbn.BigInteger(ba);
+}
+// "empty" RSA key constructor
+class RSAKey {
+    constructor() {
+        this.n = null;
+        this.e = 0;
+        this.d = null;
+        this.p = null;
+        this.q = null;
+        this.dmp1 = null;
+        this.dmq1 = null;
+        this.coeff = null;
+    }
+    //#region PROTECTED
+    // protected
+    // RSAKey.prototype.doPublic = RSADoPublic;
+    // Perform raw public operation on "x": return x^e (mod n)
+    doPublic(x) {
+        return x.modPowInt(this.e, this.n);
+    }
+    // RSAKey.prototype.doPrivate = RSADoPrivate;
+    // Perform raw private operation on "x": return x^d (mod n)
+    doPrivate(x) {
+        if (this.p == null || this.q == null) {
+            return x.modPow(this.d, this.n);
+        }
+        // TODO: re-calculate any missing CRT params
+        let xp = x.mod(this.p).modPow(this.dmp1, this.p);
+        const xq = x.mod(this.q).modPow(this.dmq1, this.q);
+        while (xp.compareTo(xq) < 0) {
+            xp = xp.add(this.p);
+        }
+        return xp.subtract(xq).multiply(this.coeff).mod(this.p).multiply(this.q).add(xq);
+    }
+    //#endregion PROTECTED
+    //#region PUBLIC
+    // RSAKey.prototype.setPublic = RSASetPublic;
+    // Set the public key fields N and e from hex strings
+    setPublic(N, E) {
+        if (N != null && E != null && N.length > 0 && E.length > 0) {
+            this.n = jsbn.parseBigInt(N, 16);
+            this.e = parseInt(E, 16);
+        }
+        else {
+            console.error("Invalid RSA public key");
+        }
+    }
+    // RSAKey.prototype.encrypt = RSAEncrypt;
+    // Return the PKCS#1 RSA encryption of "text" as an even-length hex string
+    encrypt(text) {
+        const maxLength = (this.n.bitLength() + 7) >> 3;
+        const m = pkcs1pad2(text, maxLength);
+        if (m == null) {
+            return null;
+        }
+        const c = this.doPublic(m);
+        if (c == null) {
+            return null;
+        }
+        let h = c.toString(16);
+        let length = h.length;
+        // fix zero before result
+        for (let i = 0; i < maxLength * 2 - length; i++) {
+            h = "0" + h;
+        }
+        return h;
+    }
+    // RSAKey.prototype.setPrivate = RSASetPrivate;
+    // Set the private key fields N, e, and d from hex strings
+    setPrivate(N, E, D) {
+        if (N != null && E != null && N.length > 0 && E.length > 0) {
+            this.n = jsbn.parseBigInt(N, 16);
+            this.e = parseInt(E, 16);
+            this.d = jsbn.parseBigInt(D, 16);
+        }
+        else {
+            console.error("Invalid RSA private key");
+        }
+    }
+    // RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
+    // Set the private key fields N, e, d and CRT params from hex strings
+    setPrivateEx(N, E, D, P, Q, DP, DQ, C) {
+        if (N != null && E != null && N.length > 0 && E.length > 0) {
+            this.n = jsbn.parseBigInt(N, 16);
+            this.e = parseInt(E, 16);
+            this.d = jsbn.parseBigInt(D, 16);
+            this.p = jsbn.parseBigInt(P, 16);
+            this.q = jsbn.parseBigInt(Q, 16);
+            this.dmp1 = jsbn.parseBigInt(DP, 16);
+            this.dmq1 = jsbn.parseBigInt(DQ, 16);
+            this.coeff = jsbn.parseBigInt(C, 16);
+        }
+        else {
+            console.error("Invalid RSA private key");
+        }
+    }
+    // RSAKey.prototype.generate = RSAGenerate;
+    // Generate a new random private key B bits long, using public expt E
+    generate(B, E) {
+        const rng$1 = new rng.SecureRandom();
+        const qs = B >> 1;
+        this.e = parseInt(E, 16);
+        const ee = new jsbn.BigInteger(E, 16);
+        for (;;) {
+            for (;;) {
+                this.p = new jsbn.BigInteger(B - qs, 1, rng$1);
+                if (this.p.subtract(jsbn.BigInteger.ONE).gcd(ee).compareTo(jsbn.BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) {
+                    break;
+                }
+            }
+            for (;;) {
+                this.q = new jsbn.BigInteger(qs, 1, rng$1);
+                if (this.q.subtract(jsbn.BigInteger.ONE).gcd(ee).compareTo(jsbn.BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) {
+                    break;
+                }
+            }
+            if (this.p.compareTo(this.q) <= 0) {
+                const t = this.p;
+                this.p = this.q;
+                this.q = t;
+            }
+            const p1 = this.p.subtract(jsbn.BigInteger.ONE);
+            const q1 = this.q.subtract(jsbn.BigInteger.ONE);
+            const phi = p1.multiply(q1);
+            if (phi.gcd(ee).compareTo(jsbn.BigInteger.ONE) == 0) {
+                this.n = this.p.multiply(this.q);
+                this.d = ee.modInverse(phi);
+                this.dmp1 = this.d.mod(p1);
+                this.dmq1 = this.d.mod(q1);
+                this.coeff = this.q.modInverse(this.p);
+                break;
+            }
+        }
+    }
+    // RSAKey.prototype.decrypt = RSADecrypt;
+    // Return the PKCS#1 RSA decryption of "ctext".
+    // "ctext" is an even-length hex string and the output is a plain string.
+    decrypt(ctext) {
+        const c = jsbn.parseBigInt(ctext, 16);
+        const m = this.doPrivate(c);
+        if (m == null) {
+            return null;
+        }
+        return pkcs1unpad2(m, (this.n.bitLength() + 7) >> 3);
+    }
+    // Generate a new random private key B bits long, using public expt E
+    generateAsync(B, E, callback) {
+        const rng$1 = new rng.SecureRandom();
+        const qs = B >> 1;
+        this.e = parseInt(E, 16);
+        const ee = new jsbn.BigInteger(E, 16);
+        const rsa = this;
+        // These functions have non-descript names because they were originally for(;;) loops.
+        // I don't know about cryptography to give them better names than loop1-4.
+        const loop1 = function () {
+            const loop4 = function () {
+                if (rsa.p.compareTo(rsa.q) <= 0) {
+                    const t = rsa.p;
+                    rsa.p = rsa.q;
+                    rsa.q = t;
+                }
+                const p1 = rsa.p.subtract(jsbn.BigInteger.ONE);
+                const q1 = rsa.q.subtract(jsbn.BigInteger.ONE);
+                const phi = p1.multiply(q1);
+                if (phi.gcd(ee).compareTo(jsbn.BigInteger.ONE) == 0) {
+                    rsa.n = rsa.p.multiply(rsa.q);
+                    rsa.d = ee.modInverse(phi);
+                    rsa.dmp1 = rsa.d.mod(p1);
+                    rsa.dmq1 = rsa.d.mod(q1);
+                    rsa.coeff = rsa.q.modInverse(rsa.p);
+                    setTimeout(function () { callback(); }, 0); // escape
+                }
+                else {
+                    setTimeout(loop1, 0);
+                }
+            };
+            const loop3 = function () {
+                rsa.q = jsbn.nbi();
+                rsa.q.fromNumberAsync(qs, 1, rng$1, function () {
+                    rsa.q.subtract(jsbn.BigInteger.ONE).gcda(ee, function (r) {
+                        if (r.compareTo(jsbn.BigInteger.ONE) == 0 && rsa.q.isProbablePrime(10)) {
+                            setTimeout(loop4, 0);
+                        }
+                        else {
+                            setTimeout(loop3, 0);
+                        }
+                    });
+                });
+            };
+            const loop2 = function () {
+                rsa.p = jsbn.nbi();
+                rsa.p.fromNumberAsync(B - qs, 1, rng$1, function () {
+                    rsa.p.subtract(jsbn.BigInteger.ONE).gcda(ee, function (r) {
+                        if (r.compareTo(jsbn.BigInteger.ONE) == 0 && rsa.p.isProbablePrime(10)) {
+                            setTimeout(loop3, 0);
+                        }
+                        else {
+                            setTimeout(loop2, 0);
+                        }
+                    });
+                });
+            };
+            setTimeout(loop2, 0);
+        };
+        setTimeout(loop1, 0);
+    }
+    sign(text, digestMethod, digestName) {
+        const header = getDigestHeader(digestName);
+        const digest = header + digestMethod(text).toString();
+        const m = pkcs1pad1(digest, this.n.bitLength() / 4);
+        if (m == null) {
+            return null;
+        }
+        const c = this.doPrivate(m);
+        if (c == null) {
+            return null;
+        }
+        const h = c.toString(16);
+        if ((h.length & 1) == 0) {
+            return h;
+        }
+        else {
+            return "0" + h;
+        }
+    }
+    verify(text, signature, digestMethod) {
+        const c = jsbn.parseBigInt(signature, 16);
+        const m = this.doPublic(c);
+        if (m == null) {
+            return null;
+        }
+        const unpadded = m.toString(16).replace(/^1f+00/, "");
+        const digest = removeDigestHeader(unpadded);
+        return digest == digestMethod(text).toString();
+    }
+}
+// Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
+function pkcs1unpad2(d, n) {
+    const b = d.toByteArray();
+    let i = 0;
+    while (i < b.length && b[i] == 0) {
+        ++i;
+    }
+    if (b.length - i != n - 1 || b[i] != 2) {
+        return null;
+    }
+    ++i;
+    while (b[i] != 0) {
+        if (++i >= b.length) {
+            return null;
+        }
+    }
+    let ret = "";
+    while (++i < b.length) {
+        const c = b[i] & 255;
+        if (c < 128) { // utf-8 decode
+            ret += String.fromCharCode(c);
+        }
+        else if ((c > 191) && (c < 224)) {
+            ret += String.fromCharCode(((c & 31) << 6) | (b[i + 1] & 63));
+            ++i;
+        }
+        else {
+            ret += String.fromCharCode(((c & 15) << 12) | ((b[i + 1] & 63) << 6) | (b[i + 2] & 63));
+            i += 2;
+        }
+    }
+    return ret;
+}
+// https://tools.ietf.org/html/rfc3447#page-43
+const DIGEST_HEADERS = {
+    md2: "3020300c06082a864886f70d020205000410",
+    md5: "3020300c06082a864886f70d020505000410",
+    sha1: "3021300906052b0e03021a05000414",
+    sha224: "302d300d06096086480165030402040500041c",
+    sha256: "3031300d060960864801650304020105000420",
+    sha384: "3041300d060960864801650304020205000430",
+    sha512: "3051300d060960864801650304020305000440",
+    ripemd160: "3021300906052b2403020105000414"
+};
+function getDigestHeader(name) {
+    return DIGEST_HEADERS[name] || "";
+}
+function removeDigestHeader(str) {
+    for (const name in DIGEST_HEADERS) {
+        if (DIGEST_HEADERS.hasOwnProperty(name)) {
+            const header = DIGEST_HEADERS[name];
+            const len = header.length;
+            if (str.substr(0, len) == header) {
+                return str.substr(len);
+            }
+        }
+    }
+    return str;
+}
+// Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
+// function RSAEncryptB64(text) {
+//  var h = this.encrypt(text);
+//  if(h) return hex2b64(h); else return null;
+// }
+// public
+// RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
+
+exports.RSAKey = RSAKey;

package/dist/cjs/js/src/static_dependencies/jsencrypt/lib/jsbn/util.js

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+function int2char(n) {
+    return BI_RM.charAt(n);
+}
+//#region BIT_OPERATIONS
+// (public) this & a
+function op_and(x, y) {
+    return x & y;
+}
+// (public) this | a
+function op_or(x, y) {
+    return x | y;
+}
+// (public) this ^ a
+function op_xor(x, y) {
+    return x ^ y;
+}
+// (public) this & ~a
+function op_andnot(x, y) {
+    return x & ~y;
+}
+// return index of lowest 1-bit in x, x < 2^31
+function lbit(x) {
+    if (x == 0) {
+        return -1;
+    }
+    let r = 0;
+    if ((x & 0xffff) == 0) {
+        x >>= 16;
+        r += 16;
+    }
+    if ((x & 0xff) == 0) {
+        x >>= 8;
+        r += 8;
+    }
+    if ((x & 0xf) == 0) {
+        x >>= 4;
+        r += 4;
+    }
+    if ((x & 3) == 0) {
+        x >>= 2;
+        r += 2;
+    }
+    if ((x & 1) == 0) {
+        ++r;
+    }
+    return r;
+}
+// return number of 1 bits in x
+function cbit(x) {
+    let r = 0;
+    while (x != 0) {
+        x &= x - 1;
+        ++r;
+    }
+    return r;
+}
+//#endregion BIT_OPERATIONS
+
+exports.cbit = cbit;
+exports.int2char = int2char;
+exports.lbit = lbit;
+exports.op_and = op_and;
+exports.op_andnot = op_andnot;
+exports.op_or = op_or;
+exports.op_xor = op_xor;