telegram-mtproto/lib/bin.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.strDecToHex = undefined;
exports.bigint = bigint;
exports.bigStringInt = bigStringInt;
exports.bytesToHex = bytesToHex;
exports.bytesFromHex = bytesFromHex;
exports.bytesCmp = bytesCmp;
exports.bytesXor = bytesXor;
exports.bytesToWords = bytesToWords;
exports.bytesFromWords = bytesFromWords;
exports.bytesFromLeemonBigInt = bytesFromLeemonBigInt;
exports.bytesToArrayBuffer = bytesToArrayBuffer;
exports.convertToArrayBuffer = convertToArrayBuffer;
exports.convertToUint8Array = convertToUint8Array;
exports.convertToByteArray = convertToByteArray;
exports.bytesFromArrayBuffer = bytesFromArrayBuffer;
exports.bufferConcat = bufferConcat;
exports.longToInts = longToInts;
exports.longToBytes = longToBytes;
exports.lshift32 = lshift32;
exports.intToUint = intToUint;
exports.uintToInt = uintToInt;
exports.sha1HashSync = sha1HashSync;
exports.sha1BytesSync = sha1BytesSync;
exports.sha256HashSync = sha256HashSync;
exports.rsaEncrypt = rsaEncrypt;
exports.addPadding = addPadding;
exports.aesEncryptSync = aesEncryptSync;
exports.aesDecryptSync = aesDecryptSync;
exports.gzipUncompress = gzipUncompress;
exports.nextRandomInt = nextRandomInt;
exports.pqPrimeFactorization = pqPrimeFactorization;
exports.pqPrimeLeemon = pqPrimeLeemon;
exports.bytesModPow = bytesModPow;

var _ramda = require('ramda');

var _jsbn = require('jsbn');

var _rusha = require('rusha');

var _rusha2 = _interopRequireDefault(_rusha);

var _nodeCryptojsAes = require('@goodmind/node-cryptojs-aes');

var CryptoJSlib = _interopRequireWildcard(_nodeCryptojsAes);

var _inflate = require('pako/lib/inflate');

var _secureRandom = require('./service/secure-random');

var _secureRandom2 = _interopRequireDefault(_secureRandom);

var _leemon = require('./vendor/leemon');

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const { CryptoJS } = CryptoJSlib;

// import Timer from 'hirestime' //TODO remove in prod!

const rushaInstance = new _rusha2.default(1024 * 1024);

function bigint(num) {
  return new _jsbn.BigInteger(num.toString(16), 16);
}

function bigStringInt(strNum) {
  return new _jsbn.BigInteger(strNum, 10);
}

// export const rShift32 = str => {
//   const num = str2bigInt(str, 10, 0)
//   rightShift_(num, 32)
//   return bigInt2str(num, 10)
// }
const strDecToHex = exports.strDecToHex = str => (0, _ramda.toLower)((0, _leemon.bigInt2str)((0, _leemon.str2bigInt)(str, 10, 0), 16));

function bytesToHex(bytes = []) {
  const arr = [];
  for (let i = 0; i < bytes.length; i++) {
    arr.push((bytes[i] < 16 ? '0' : '') + (bytes[i] || 0).toString(16));
  }
  return arr.join('');
}

function bytesFromHex(hexString) {
  const len = hexString.length;
  let start = 0;
  const bytes = [];

  if (hexString.length % 2) {
    bytes.push(parseInt(hexString.charAt(0), 16));
    start++;
  }

  for (let i = start; i < len; i += 2) {
    bytes.push(parseInt(hexString.substr(i, 2), 16));
  }

  return bytes;
}

function bytesCmp(bytes1, bytes2) {
  const len = bytes1.length;
  if (len !== bytes2.length) {
    return false;
  }

  for (let i = 0; i < len; i++) {
    if (bytes1[i] !== bytes2[i]) return false;
  }
  return true;
}

function bytesXor(bytes1, bytes2) {
  const len = bytes1.length;
  const bytes = [];

  for (let i = 0; i < len; ++i) {
    bytes[i] = bytes1[i] ^ bytes2[i];
  }

  return bytes;
}

function bytesToWords(bytes) {
  if (bytes instanceof ArrayBuffer) {
    bytes = new Uint8Array(bytes);
  }
  const len = bytes.length;
  const words = [];
  let i;
  for (i = 0; i < len; i++) {
    words[i >>> 2] |= bytes[i] << 24 - i % 4 * 8;
  }

  return new CryptoJS.lib.WordArray.init(words, len);
}

function bytesFromWords(wordArray) {
  const words = wordArray.words;
  const sigBytes = wordArray.sigBytes;
  const bytes = [];

  for (let i = 0; i < sigBytes; i++) {
    bytes.push(words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff);
  }

  return bytes;
}

function bytesFromLeemonBigInt(bigInt) {
  const str = (0, _leemon.bigInt2str)(bigInt, 16);
  return bytesFromHex(str);
}

function bytesToArrayBuffer(b) {
  return new Uint8Array(b).buffer;
}

function convertToArrayBuffer(bytes) {
  // Be careful with converting subarrays!!
  if (bytes instanceof ArrayBuffer) {
    return bytes;
  }
  if (bytes.buffer !== undefined && bytes.buffer.byteLength == bytes.length * bytes.BYTES_PER_ELEMENT) {
    return bytes.buffer;
  }
  return bytesToArrayBuffer(bytes);
}

function convertToUint8Array(bytes) {
  if (bytes.buffer !== undefined) return bytes;
  return new Uint8Array(bytes);
}

function convertToByteArray(bytes) {
  if (Array.isArray(bytes)) return bytes;
  bytes = convertToUint8Array(bytes);
  const newBytes = [];
  for (let i = 0, len = bytes.length; i < len; i++) newBytes.push(bytes[i]);
  return newBytes;
}

function bytesFromArrayBuffer(buffer) {
  const byteView = new Uint8Array(buffer);
  const bytes = Array.from(byteView);
  return bytes;
}

function bufferConcat(buffer1, buffer2) {
  const l1 = buffer1.byteLength || buffer1.length;
  const l2 = buffer2.byteLength || buffer2.length;
  const tmp = new Uint8Array(l1 + l2);
  tmp.set(buffer1 instanceof ArrayBuffer ? new Uint8Array(buffer1) : buffer1, 0);
  tmp.set(buffer2 instanceof ArrayBuffer ? new Uint8Array(buffer2) : buffer2, l1);

  return tmp.buffer;
}

// const dividerBig = bigint(0x100000000)
const dividerLem = (0, _leemon.str2bigInt)('100000000', 16, 4);

// const printTimers = (timeL, timeB, a, b, n) => setTimeout(
//   () => console.log(`Timer L ${timeL} B ${timeB}`, ...a, ...b, n || ''),
//   100)

function longToInts(sLong) {
  /*const bigTime = Timer()
  const divRem = bigStringInt(sLong).divideAndRemainder(dividerBig)
  const divIntB = divRem[0].intValue()
  const remIntB = divRem[1].intValue()
  const resB = [
    intToUint(divIntB),
    intToUint(remIntB)
  ]
  const timeB = bigTime()*/

  // const lemTime = Timer()
  const lemNum = (0, _leemon.str2bigInt)(sLong, 10, 6);
  const div = new Array(lemNum.length);
  const rem = new Array(lemNum.length);
  (0, _leemon.divide_)(lemNum, dividerLem, div, rem);
  const resL = [~~(0, _leemon.bigInt2str)(div, 10), ~~(0, _leemon.bigInt2str)(rem, 10)];
  // const timeL = lemTime()

  // printTimers(timeL, timeB, resL, resB)
  return resL;
}

function longToBytes(sLong) {
  return bytesFromWords({ words: longToInts(sLong), sigBytes: 8 }).reverse();
}

function lshift32(high, low) {
  const highNum = (0, _leemon.int2bigInt)(high, 96, 0);
  (0, _leemon.leftShift_)(highNum, 32);

  (0, _leemon.addInt_)(highNum, low);
  const res = (0, _leemon.bigInt2str)(highNum, 10);
  return res;
}

// export function longFromLem(high, low) {
//   const highNum = int2bigInt(high, 96, 0)
//   leftShift_(highNum, 32)

//   addInt_(highNum, low)
//   const res = bigInt2str(highNum, 10)
//   return res
// }

function intToUint(val) {
  val = parseInt(val); //TODO PERF parseInt is a perfomance issue
  if (val < 0) val = val + 4294967296;
  return val;
}

function uintToInt(val) {
  if (val > 2147483647) val = val - 4294967296;
  return val;
}

function sha1HashSync(bytes) {
  // console.log(dT(), 'SHA-1 hash start', bytes.byteLength || bytes.length)
  const hashBytes = rushaInstance.rawDigest(bytes).buffer;
  // console.log(dT(), 'SHA-1 hash finish')

  return hashBytes;
}

function sha1BytesSync(bytes) {
  return bytesFromArrayBuffer(sha1HashSync(bytes));
}

function sha256HashSync(bytes) {
  // console.log(dT(), 'SHA-2 hash start', bytes.byteLength || bytes.length)
  const hashWords = CryptoJS.SHA256(bytesToWords(bytes));
  // console.log(dT(), 'SHA-2 hash finish')

  const hashBytes = bytesFromWords(hashWords);

  return hashBytes;
}

function rsaEncrypt(publicKey, bytes) {
  bytes = addPadding(bytes, 255);

  const N = (0, _leemon.str2bigInt)(publicKey.modulus, 16, 256);
  const E = (0, _leemon.str2bigInt)(publicKey.exponent, 16, 256);
  const X = (0, _leemon.str2bigInt)(bytesToHex(bytes), 16, 256);
  const encryptedBigInt = (0, _leemon.powMod)(X, E, N),
        encryptedBytes = bytesFromHex((0, _leemon.bigInt2str)(encryptedBigInt, 16));

  return encryptedBytes;
}

function addPadding(bytes, blockSize, zeroes) {
  blockSize = blockSize || 16;
  const len = bytes.byteLength || bytes.length;
  const needPadding = blockSize - len % blockSize;
  if (needPadding > 0 && needPadding < blockSize) {
    const padding = new Array(needPadding);
    if (zeroes) {
      for (let i = 0; i < needPadding; i++) padding[i] = 0;
    } else _secureRandom2.default.nextBytes(padding);

    bytes = bytes instanceof ArrayBuffer ? bufferConcat(bytes, padding) : bytes.concat(padding);
  }

  return bytes;
}

function aesEncryptSync(bytes, keyBytes, ivBytes) {
  const len = bytes.byteLength || bytes.length;

  // console.log(dT(), 'AES encrypt start', len/*, bytesToHex(keyBytes), bytesToHex(ivBytes)*/)
  bytes = addPadding(bytes);

  const encryptedWords = CryptoJS.AES.encrypt(bytesToWords(bytes), bytesToWords(keyBytes), {
    iv: bytesToWords(ivBytes),
    padding: CryptoJS.pad.NoPadding,
    mode: CryptoJS.mode.IGE
  }).ciphertext;

  const encryptedBytes = bytesFromWords(encryptedWords);
  // console.log(dT(), 'AES encrypt finish')

  return encryptedBytes;
}

function aesDecryptSync(encryptedBytes, keyBytes, ivBytes) {

  // console.log(dT(), 'AES decrypt start', encryptedBytes.length)
  const decryptedWords = CryptoJS.AES.decrypt({ ciphertext: bytesToWords(encryptedBytes) }, bytesToWords(keyBytes), {
    iv: bytesToWords(ivBytes),
    padding: CryptoJS.pad.NoPadding,
    mode: CryptoJS.mode.IGE
  });

  const bytes = bytesFromWords(decryptedWords);
  // console.log(dT(), 'AES decrypt finish')

  return bytes;
}

function gzipUncompress(bytes) {
  // console.log('Gzip uncompress start')
  const result = (0, _inflate.inflate)(bytes);
  // console.log('Gzip uncompress finish')
  return result;
}

function nextRandomInt(maxValue) {
  return Math.floor(Math.random() * maxValue);
}

function pqPrimeFactorization(pqBytes) {
  const minSize = Math.ceil(64 / _leemon.bpe) + 1;

  // const what = new BigInteger(pqBytes)
  const hex = bytesToHex(pqBytes);
  const lWhat = (0, _leemon.str2bigInt)(hex, 16, minSize);
  const result = pqPrimeLeemon(lWhat);
  return result;
}

function pqPrimeLeemon(what) {
  const minBits = 64;
  const minLen = Math.ceil(minBits / _leemon.bpe) + 1;
  let it = 0;
  let q, lim;
  const a = new Array(minLen);
  const b = new Array(minLen);
  const c = new Array(minLen);
  const g = new Array(minLen);
  const z = new Array(minLen);
  const x = new Array(minLen);
  const y = new Array(minLen);

  for (let i = 0; i < 3; i++) {
    q = (nextRandomInt(128) & 15) + 17;
    (0, _leemon.copyInt_)(x, nextRandomInt(1000000000) + 1);
    (0, _leemon.copy_)(y, x);
    lim = 1 << i + 18;

    for (let j = 1; j < lim; j++) {
      ++it;
      (0, _leemon.copy_)(a, x);
      (0, _leemon.copy_)(b, x);
      (0, _leemon.copyInt_)(c, q);

      while (!(0, _leemon.isZero)(b)) {
        if (b[0] & 1) {
          (0, _leemon.add_)(c, a);
          if ((0, _leemon.greater)(c, what)) {
            (0, _leemon.sub_)(c, what);
          }
        }
        (0, _leemon.add_)(a, a);
        if ((0, _leemon.greater)(a, what)) {
          (0, _leemon.sub_)(a, what);
        }
        (0, _leemon.rightShift_)(b, 1);
      }

      (0, _leemon.copy_)(x, c);
      if ((0, _leemon.greater)(x, y)) {
        (0, _leemon.copy_)(z, x);
        (0, _leemon.sub_)(z, y);
      } else {
        (0, _leemon.copy_)(z, y);
        (0, _leemon.sub_)(z, x);
      }
      (0, _leemon.eGCD_)(z, what, g, a, b);
      if (!(0, _leemon.equalsInt)(g, 1)) {
        break;
      }
      if ((j & j - 1) === 0) {
        (0, _leemon.copy_)(y, x);
      }
    }
    if ((0, _leemon.greater)(g, _leemon.one)) {
      break;
    }
  }

  (0, _leemon.divide_)(what, g, x, y);

  const [P, Q] = (0, _leemon.greater)(g, x) ? [x, g] : [g, x];

  // console.log(dT(), 'done', bigInt2str(what, 10), bigInt2str(P, 10), bigInt2str(Q, 10))

  return [bytesFromLeemonBigInt(P), bytesFromLeemonBigInt(Q), it];
}

function bytesModPow(x, y, m) {
  const xBigInt = (0, _leemon.str2bigInt)(bytesToHex(x), 16);
  const yBigInt = (0, _leemon.str2bigInt)(bytesToHex(y), 16);
  const mBigInt = (0, _leemon.str2bigInt)(bytesToHex(m), 16);
  const resBigInt = (0, _leemon.powMod)(xBigInt, yBigInt, mBigInt);

  return bytesFromHex((0, _leemon.bigInt2str)(resBigInt, 16));
}
//# sourceMappingURL=bin.js.map