telegram-mtproto/lib/crypto.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CryptoWorker = undefined;

var _ramda = require('ramda');

var _detectNode = require('detect-node');

var _detectNode2 = _interopRequireDefault(_detectNode);

var _defer = require('./defer');

var _defer2 = _interopRequireDefault(_defer);

var _smartTimeout = require('./smart-timeout');

var _smartTimeout2 = _interopRequireDefault(_smartTimeout);

var _bin = require('./bin');

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

const convertIfArray = (0, _ramda.when)((0, _ramda.is)(Array), _bin.convertToUint8Array);
let webWorker = !_detectNode2.default;
let taskID = 0;
const awaiting = {};
const webCrypto = _detectNode2.default ? false
//eslint-disable-next-line
: window.crypto.subtle || window.crypto.webkitSubtle //TODO remove browser depends
//eslint-disable-next-line
|| window.msCrypto && window.msCrypto.subtle;
const useWebCrypto = webCrypto && !!webCrypto.digest;
let useSha1Crypto = useWebCrypto;
let useSha256Crypto = useWebCrypto;
const finalizeTask = (taskID, result) => {
  const deferred = awaiting[taskID];
  if (deferred) {
    // console.log(rework_d_T(), 'CW done')
    deferred.resolve(result); //TODO Possibly, can be used as
    delete awaiting[taskID]; //
  } //    deferred = Promise.resolve()
}; //    deferred.resolve( result )

const isCryptoTask = (0, _ramda.both)((0, _ramda.has)('taskID'), (0, _ramda.has)('result'));

//eslint-disable-next-line
const workerEnable = !_detectNode2.default && window.Worker;
if (workerEnable) {
  require('worker-loader!./worker.js');
  const tmpWorker = new Worker('./bundle/hash.worker.js');
  // tmpWorker.onmessage = function(event) {
  //   console.info('CW tmpWorker.onmessage', event && event.data)
  // }
  tmpWorker.onmessage = e => {
    if (e.data === 'ready') {
      console.info('CW ready');
    } else if (!isCryptoTask(e.data)) {
      console.info('Not crypto task', e, e.data);
      return e;
    } else return webWorker ? finalizeTask(e.data.taskID, e.data.result) : webWorker = tmpWorker;
  };

  tmpWorker.onerror = function (error) {
    console.error('CW error', error, error.stack);
    webWorker = false;
  };
  tmpWorker.postMessage('b');
  webWorker = tmpWorker;
}

const performTaskWorker = (task, params, embed) => {
  // console.log(rework_d_T(), 'CW start', task)
  const deferred = (0, _defer2.default)();

  awaiting[taskID] = deferred;

  params.task = task;
  params.taskID = taskID;(embed || webWorker).postMessage(params);

  taskID++;

  return deferred.promise;
};

const sha1Hash = bytes => {
  if (useSha1Crypto) {
    // We don't use buffer since typedArray.subarray(...).buffer gives the whole buffer and not sliced one.
    // webCrypto.digest supports typed array
    const bytesTyped = convertIfArray(bytes);
    // console.log(rework_d_T(), 'Native sha1 start')
    return webCrypto.digest({ name: 'SHA-1' }, bytesTyped).then(digest =>
    // console.log(rework_d_T(), 'Native sha1 done')
    digest, e => {
      console.error('Crypto digest error', e);
      useSha1Crypto = false;
      return (0, _bin.sha1HashSync)(bytes);
    });
  }
  return _smartTimeout2.default.immediate(_bin.sha1HashSync, bytes);
};

const sha256Hash = bytes => {
  if (useSha256Crypto) {
    const bytesTyped = convertIfArray(bytes);
    // console.log(rework_d_T(), 'Native sha1 start')
    return webCrypto.digest({ name: 'SHA-256' }, bytesTyped).then(_ramda.identity
    // console.log(rework_d_T(), 'Native sha1 done')
    , e => {
      console.error('Crypto digest error', e);
      useSha256Crypto = false;
      return (0, _bin.sha256HashSync)(bytes);
    });
  }
  return _smartTimeout2.default.immediate(_bin.sha256HashSync, bytes);
};

const aesEncrypt = (bytes, keyBytes, ivBytes) => _smartTimeout2.default.immediate(() => (0, _bin.convertToArrayBuffer)((0, _bin.aesEncryptSync)(bytes, keyBytes, ivBytes)));

const aesDecrypt = (encryptedBytes, keyBytes, ivBytes) => _smartTimeout2.default.immediate(() => (0, _bin.convertToArrayBuffer)((0, _bin.aesDecryptSync)(encryptedBytes, keyBytes, ivBytes)));

const factorize = bytes => {
  bytes = (0, _bin.convertToByteArray)(bytes);
  return webWorker ? performTaskWorker('factorize', { bytes }) : _smartTimeout2.default.immediate(_bin.pqPrimeFactorization, bytes);
};

const modPow = (x, y, m) => webWorker ? performTaskWorker('mod-pow', {
  x,
  y,
  m
}) : _smartTimeout2.default.immediate(_bin.bytesModPow, x, y, m);

const CryptoWorker = exports.CryptoWorker = {
  sha1Hash,
  sha256Hash,
  aesEncrypt,
  aesDecrypt,
  factorize,
  modPow
};

exports.default = CryptoWorker;
//# sourceMappingURL=crypto.js.map