madeline-ton
Version:
Pure JS client-side implementation of the Telegram TON blockchain protocol
314 lines (280 loc) • 7.05 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _poly = require("../crypto-sync/poly");
var _c = _interopRequireDefault(require("./c.worker"));
var CryptoWorker =
/*#__PURE__*/
function () {
function CryptoWorker(parser, timeout) {
var _this = this;
(0, _classCallCheck2["default"])(this, CryptoWorker);
this.tasks = [];
this.timeout = timeout || 200000; // Change later
this.worker = new _c["default"]();
this.worker.onmessage = this.onMessage.bind(this);
if (!_poly.useWebCryptoRandom && typeof window !== 'undefined') {
window.onkeydown = window.onclick = function () {
return _this.worker.postMessage({
task: 'seed'
});
};
}
this.worker.postMessage({
task: 'init' //parser
});
}
(0, _createClass2["default"])(CryptoWorker, [{
key: "onMessage",
value: function onMessage(message) {
message = message['data'];
if (!this.tasks[message['id']]) return;
if (message['e']) {
this.tasks[message['id']][1](message['e']);
} else {
this.tasks[message['id']][0](message['result']);
}
delete this.tasks[message['id']];
}
}, {
key: "asyncTask",
value: function asyncTask(params) {
var _this2 = this;
params['id'] = this.tasks.length;
return new Promise(function (resolve, reject) {
_this2.tasks.push([resolve, reject]);
setTimeout(function () {
return reject("Crypto worker timeout for task " + params['task'] + "!");
}, params['task'] === 'factorize' ? 5 * 60 * 1000 : _this2.timeout, params['id']);
_this2.worker.postMessage(params);
});
}
/**
* Factorize semiprime
* @param {Uint8Array} what Number to factorize
* @returns Uint8Array[]
*/
}, {
key: "factorize",
value: function factorize(what) {
return this.asyncTask({
task: 'factorize',
what: what
});
}
/**
* Fill buffer with secure random values
* @param {BufferSource} buffer Buffer to fill
*/
}, {
key: "secureRandom",
value: function secureRandom(buffer) {
return this.asyncTask({
task: 'secureRandom',
buffer: buffer
});
}
/**
* Get secure random number modulo modulus
* @param {number} mod Modulus
*/
}, {
key: "secureRandomInt",
value: function secureRandomInt(mod) {
return this.asyncTask({
task: 'secureRandomInt',
mod: mod
});
}
/**
* SHA1
* @param {Uint32Array} data Data to hash
* @returns {ArrayBuffer}
*/
}, {
key: "sha1",
value: function sha1(buffer) {
return this.asyncTask({
task: 'sha1',
buffer: buffer
});
}
/**
* SHA256
* @param {Uint32Array} data Data to hash
* @returns {ArrayBuffer}
*/
}, {
key: "sha256",
value: function sha256(buffer) {
return this.asyncTask({
task: 'sha256',
buffer: buffer
});
}
/**
* Encrypt data using AES IGE
* @param {Uint32Array} data Data
* @param {Uint32Array} key Key
* @param {Uint32Array} iv IV
* @returns {ArrayBuffer}
*/
}, {
key: "igeEncrypt",
value: function igeEncrypt(data, key, iv) {
return this.asyncTask({
task: 'igeEncrypt',
data: data,
key: key,
iv: iv
});
}
/**
* Decrypt data using AES IGE
* @param {Uint32Array} data Data
* @param {Uint32Array} key Key
* @param {Uint32Array} iv IV
* @returns {ArrayBuffer}
*/
}, {
key: "igeDecrypt",
value: function igeDecrypt(data, key, iv) {
return this.asyncTask({
task: 'igeDecrypt',
data: data,
key: key,
iv: iv
});
}
/**
* Bigint PowMod
* @param {leemonBigInt} b Hex base
* @param {leemonBigInt} e Hex exponent
* @param {leemonBigInt} n Hex modulus
* @returns {leemonBigInt} Result
*/
}, {
key: "powMod",
value: function powMod(b, e, n) {
return this.asyncTask({
task: 'powMod',
b: b,
e: e,
n: n
});
}
/**
* Check validity of diffie hellman parameters
* @param {BigInt} p Hex prime
* @param {BigInt} g Hex generator
* @param {BigInt} G_ Hex generated
*/
}, {
key: "checkAll",
value: function checkAll(p, g, G_) {
return this.asyncTask({
task: 'checkAll',
p: p,
g: g,
G_: G_
});
}
/**
* Check validity of diffie hellman parameters
* @param {BigInt} G_ Hex generated
* @param {BigInt} p Hex prime
*/
}, {
key: "checkG",
value: function checkG(G_, p) {
return this.asyncTask({
task: 'checkG',
G_: G_,
p: p
});
}
/**
* Deserialize TL payload
* @param {Stream} data Data
* @returns {Object}
*/
}, {
key: "deserialize",
value: function deserialize(data) {
return this.asyncTask({
task: 'deserialize',
data: data
});
}
/**
* Generate elliptic-curve init context
* @param {Uint32Array} peerPublic Peer's public Ed25519 key
* @returns {Object}
*/
}, {
key: "initEC",
value: function initEC(peerPublic) {
return this.asyncTask({
task: 'initEC',
peerPublic: peerPublic
});
}
/**
* Get crc16 checksum of data
* @param {Uint8Array} data Data
* @returns {Uint8Array} Checksum
*/
}, {
key: "crc16",
value: function crc16(data) {
return this.asyncTask({
task: 'crc16',
data: data
});
}
/**
* Get continuous CTR processor
* @param {Uint32Array} iv
* @param {Uint32Array} key
* @returns CtrProcessor
*/
/*
getCtr(key, iv) {
return this.asyncTask({
task: 'ctrInit',
key,
iv
}).then(id => {
return {
process: this.asyncCtrTask.bind({
task: 'ctr',
wrapper: this,
id
}),
close: this.asyncCtrTask.bind({
task: 'ctrClose',
wrapper: this,
id
}),
}
})
}*/
}, {
key: "asyncCtrTask",
value: function asyncCtrTask(data) {
return this.wrapper.asyncTask({
task: this.task,
ctrId: this.id,
data: data
});
}
}]);
return CryptoWorker;
}();
var _default = CryptoWorker;
exports["default"] = _default;