diff --git a/dist/index.js b/dist/index.js index 48c1c2c0..2c49c630 100644 --- a/dist/index.js +++ b/dist/index.js @@ -88,7 +88,7 @@ module.exports = /******/ __webpack_require__.p = ""; /******/ /******/ // Load entry module and return exports -/******/ return __webpack_require__(__webpack_require__.s = 89); +/******/ return __webpack_require__(__webpack_require__.s = 97); /******/ }) /************************************************************************/ /******/ ([ @@ -102,7 +102,7 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var chance_1 = __webpack_require__(82); +var chance_1 = __webpack_require__(91); var JSFuck_1 = __webpack_require__(21); var Utils = function () { @@ -285,138 +285,16 @@ exports.Utils = Utils; /***/ }, /* 1 */ -/***/ function(module, exports, __webpack_require__) { +/***/ function(module, exports) { "use strict"; "use strict"; -var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var escodegen = __webpack_require__(13); -var esprima = __webpack_require__(24); -var estraverse = __webpack_require__(4); -var NodeType_1 = __webpack_require__(6); -var Node_1 = __webpack_require__(2); -var Utils_1 = __webpack_require__(0); - -var NodeUtils = function () { - function NodeUtils() { - _classCallCheck(this, NodeUtils); - } - - _createClass(NodeUtils, null, [{ - key: 'addXVerbatimPropertyToLiterals', - value: function addXVerbatimPropertyToLiterals(node) { - NodeUtils.typedReplace(node, NodeType_1.NodeType.Literal, { - leave: function leave(node) { - node['x-verbatim-property'] = { - content: node.raw, - precedence: escodegen.Precedence.Primary - }; - } - }); - } - }, { - key: 'convertCodeToStructure', - value: function convertCodeToStructure(code) { - var structure = esprima.parse(code); - NodeUtils.addXVerbatimPropertyToLiterals(structure); - NodeUtils.parentize(structure); - return structure.body; - } - }, { - key: 'getBlockStatementNodeByIndex', - value: function getBlockStatementNodeByIndex(node) { - var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - - if (Node_1.Node.isNodeHasBlockStatement(node)) { - if (node.body[index] === undefined) { - throw new ReferenceError('Wrong index `' + index + '`. Block-statement body length is `' + node.body.length + '`'); - } - return node.body[index]; - } - throw new TypeError('The specified node have no a block-statement'); - } - }, { - key: 'getBlockScopeOfNode', - value: function getBlockScopeOfNode(node) { - var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; - - var parentNode = node.parentNode; - if (!parentNode) { - throw new ReferenceError('`parentNode` property of given node is `undefined`'); - } - if (Node_1.Node.isBlockStatementNode(parentNode)) { - if (!parentNode.parentNode) { - throw new ReferenceError('`parentNode` property of `parentNode` of given node is `undefined`'); - } - if (!Utils_1.Utils.arrayContains(NodeUtils.nodesWithBlockScope, parentNode.parentNode.type)) { - return NodeUtils.getBlockScopeOfNode(parentNode, depth); - } else if (depth > 0) { - return NodeUtils.getBlockScopeOfNode(parentNode, --depth); - } - return parentNode; - } - if (Node_1.Node.isProgramNode(parentNode)) { - return parentNode; - } - return NodeUtils.getBlockScopeOfNode(parentNode); - } - }, { - key: 'parentize', - value: function parentize(node) { - var isRootNode = true; - estraverse.replace(node, { - enter: function enter(node, parentNode) { - var value = void 0; - if (isRootNode) { - if (node.type === NodeType_1.NodeType.Program) { - value = node; - } else { - value = Node_1.Node.getProgramNode([node]); - value.parentNode = value; - } - isRootNode = false; - } else { - value = parentNode || node; - } - node.parentNode = value; - node.obfuscated = false; - } - }); - } - }, { - key: 'typedReplace', - value: function typedReplace(node, nodeType, visitor) { - NodeUtils.typedTraverse(node, nodeType, visitor, 'replace'); - } - }, { - key: 'typedTraverse', - value: function typedTraverse(node, nodeType, visitor) { - var traverseType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'traverse'; - - estraverse[traverseType](node, { - enter: function enter(node, parentNode) { - if (node.type === nodeType && visitor.enter) { - visitor.enter(node, parentNode); - } - }, - leave: function leave(node, parentNode) { - if (node.type === nodeType && visitor.leave) { - visitor.leave(node, parentNode); - } - } - }); - } - }]); - - return NodeUtils; -}(); - -NodeUtils.nodesWithBlockScope = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression, NodeType_1.NodeType.MethodDefinition, NodeType_1.NodeType.Program]; -exports.NodeUtils = NodeUtils; +(function (AppendState) { + AppendState[AppendState["AfterObfuscation"] = 0] = "AfterObfuscation"; + AppendState[AppendState["BeforeObfuscation"] = 1] = "BeforeObfuscation"; +})(exports.AppendState || (exports.AppendState = {})); +var AppendState = exports.AppendState; /***/ }, /* 2 */ @@ -563,25 +441,6 @@ exports.Node = Node; /***/ }, /* 3 */ -/***/ function(module, exports) { - -"use strict"; -"use strict"; - -(function (AppendState) { - AppendState[AppendState["AfterObfuscation"] = 0] = "AfterObfuscation"; - AppendState[AppendState["BeforeObfuscation"] = 1] = "BeforeObfuscation"; -})(exports.AppendState || (exports.AppendState = {})); -var AppendState = exports.AppendState; - -/***/ }, -/* 4 */ -/***/ function(module, exports) { - -module.exports = require("estraverse"); - -/***/ }, -/* 5 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -707,6 +566,59 @@ var NodeAppender = function () { exports.NodeAppender = NodeAppender; +/***/ }, +/* 4 */ +/***/ function(module, exports) { + +module.exports = require("estraverse"); + +/***/ }, +/* 5 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var NodeUtils_1 = __webpack_require__(7); + +var AbstractCustomNode = function () { + function AbstractCustomNode(options) { + _classCallCheck(this, AbstractCustomNode); + + this.options = options; + } + + _createClass(AbstractCustomNode, [{ + key: "getAppendState", + value: function getAppendState() { + return this.appendState; + } + }, { + key: "getNode", + value: function getNode() { + return this.getNodeStructure(); + } + }, { + key: "setAppendState", + value: function setAppendState(appendState) { + this.appendState = appendState; + } + }, { + key: "getNodeStructure", + value: function getNodeStructure() { + return NodeUtils_1.NodeUtils.convertCodeToStructure(this.getCode()); + } + }]); + + return AbstractCustomNode; +}(); + +exports.AbstractCustomNode = AbstractCustomNode; + /***/ }, /* 6 */ /***/ function(module, exports, __webpack_require__) { @@ -750,7 +662,7 @@ exports.NodeType = Utils_1.Utils.strEnumify({ /***/ }, /* 7 */ -/***/ function(module, exports) { +/***/ function(module, exports, __webpack_require__) { "use strict"; "use strict"; @@ -759,39 +671,140 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var AbstractCustomNode = function () { - function AbstractCustomNode(options) { - _classCallCheck(this, AbstractCustomNode); +var escodegen = __webpack_require__(14); +var esprima = __webpack_require__(24); +var estraverse = __webpack_require__(4); +var NodeType_1 = __webpack_require__(6); +var Node_1 = __webpack_require__(2); +var Utils_1 = __webpack_require__(0); - this.options = options; +var NodeUtils = function () { + function NodeUtils() { + _classCallCheck(this, NodeUtils); } - _createClass(AbstractCustomNode, [{ - key: "getAppendState", - value: function getAppendState() { - return this.appendState; + _createClass(NodeUtils, null, [{ + key: 'addXVerbatimPropertyToLiterals', + value: function addXVerbatimPropertyToLiterals(node) { + NodeUtils.typedReplace(node, NodeType_1.NodeType.Literal, { + leave: function leave(node) { + node['x-verbatim-property'] = { + content: node.raw, + precedence: escodegen.Precedence.Primary + }; + } + }); } }, { - key: "getNode", - value: function getNode() { - return this.getNodeStructure(); + key: 'convertCodeToStructure', + value: function convertCodeToStructure(code) { + var structure = esprima.parse(code); + NodeUtils.addXVerbatimPropertyToLiterals(structure); + NodeUtils.parentize(structure); + return structure.body; } }, { - key: "setAppendState", - value: function setAppendState(appendState) { - this.appendState = appendState; + key: 'getBlockStatementNodeByIndex', + value: function getBlockStatementNodeByIndex(node) { + var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + + if (Node_1.Node.isNodeHasBlockStatement(node)) { + if (node.body[index] === undefined) { + throw new ReferenceError('Wrong index `' + index + '`. Block-statement body length is `' + node.body.length + '`'); + } + return node.body[index]; + } + throw new TypeError('The specified node have no a block-statement'); + } + }, { + key: 'getBlockScopeOfNode', + value: function getBlockScopeOfNode(node) { + var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + + var parentNode = node.parentNode; + if (!parentNode) { + throw new ReferenceError('`parentNode` property of given node is `undefined`'); + } + if (Node_1.Node.isBlockStatementNode(parentNode)) { + if (!parentNode.parentNode) { + throw new ReferenceError('`parentNode` property of `parentNode` of given node is `undefined`'); + } + if (!Utils_1.Utils.arrayContains(NodeUtils.nodesWithBlockScope, parentNode.parentNode.type)) { + return NodeUtils.getBlockScopeOfNode(parentNode, depth); + } else if (depth > 0) { + return NodeUtils.getBlockScopeOfNode(parentNode, --depth); + } + return parentNode; + } + if (Node_1.Node.isProgramNode(parentNode)) { + return parentNode; + } + return NodeUtils.getBlockScopeOfNode(parentNode); + } + }, { + key: 'parentize', + value: function parentize(node) { + var isRootNode = true; + estraverse.replace(node, { + enter: function enter(node, parentNode) { + var value = void 0; + if (isRootNode) { + if (node.type === NodeType_1.NodeType.Program) { + value = node; + } else { + value = Node_1.Node.getProgramNode([node]); + value.parentNode = value; + } + isRootNode = false; + } else { + value = parentNode || node; + } + node.parentNode = value; + node.obfuscated = false; + } + }); + } + }, { + key: 'typedReplace', + value: function typedReplace(node, nodeType, visitor) { + NodeUtils.typedTraverse(node, nodeType, visitor, 'replace'); + } + }, { + key: 'typedTraverse', + value: function typedTraverse(node, nodeType, visitor) { + var traverseType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'traverse'; + + estraverse[traverseType](node, { + enter: function enter(node, parentNode) { + if (node.type === nodeType && visitor.enter) { + visitor.enter(node, parentNode); + } + }, + leave: function leave(node, parentNode) { + if (node.type === nodeType && visitor.leave) { + visitor.leave(node, parentNode); + } + } + }); } }]); - return AbstractCustomNode; + return NodeUtils; }(); -exports.AbstractCustomNode = AbstractCustomNode; +NodeUtils.nodesWithBlockScope = [NodeType_1.NodeType.ArrowFunctionExpression, NodeType_1.NodeType.FunctionDeclaration, NodeType_1.NodeType.FunctionExpression, NodeType_1.NodeType.MethodDefinition, NodeType_1.NodeType.Program]; +exports.NodeUtils = NodeUtils; /***/ }, /* 8 */ /***/ function(module, exports) { +module.exports = require("format-unicorn"); + +/***/ }, +/* 9 */ +/***/ function(module, exports) { + "use strict"; "use strict"; @@ -806,12 +819,6 @@ var AbstractNodeObfuscator = function AbstractNodeObfuscator(nodes, options) { exports.AbstractNodeObfuscator = AbstractNodeObfuscator; -/***/ }, -/* 9 */ -/***/ function(module, exports) { - -module.exports = require("format-unicorn"); - /***/ }, /* 10 */ /***/ function(module, exports, __webpack_require__) { @@ -823,8 +830,8 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var JavaScriptObfuscatorCLI_1 = __webpack_require__(32); -var JavaScriptObfuscatorInternal_1 = __webpack_require__(27); +var JavaScriptObfuscatorCLI_1 = __webpack_require__(33); +var JavaScriptObfuscatorInternal_1 = __webpack_require__(28); var JavaScriptObfuscator = function () { function JavaScriptObfuscator() { @@ -863,7 +870,7 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var AppendState_1 = __webpack_require__(3); +var AppendState_1 = __webpack_require__(1); var AbstractNodesGroup = function () { function AbstractNodesGroup(stackTraceData, options) { @@ -906,7 +913,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var AbstractReplacer_1 = __webpack_require__(15); +var AbstractReplacer_1 = __webpack_require__(16); var Utils_1 = __webpack_require__(0); var IdentifierReplacer = function (_AbstractReplacer_1$A) { @@ -953,50 +960,15 @@ exports.IdentifierReplacer = IdentifierReplacer; /***/ }, /* 13 */ -/***/ function(module, exports) { - -module.exports = require("escodegen"); - -/***/ }, -/* 14 */ -/***/ function(module, exports) { - -"use strict"; -"use strict"; - -exports.SourceMapMode = { - Inline: 'inline', - Separate: 'separate' -}; - -/***/ }, -/* 15 */ -/***/ function(module, exports) { - -"use strict"; -"use strict"; - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var AbstractReplacer = function AbstractReplacer(nodes, options) { - _classCallCheck(this, AbstractReplacer); - - this.nodes = nodes; - this.options = options; -}; - -exports.AbstractReplacer = AbstractReplacer; - -/***/ }, -/* 16 */ /***/ function(module, exports, __webpack_require__) { "use strict"; "use strict"; -var SourceMapMode_1 = __webpack_require__(14); +var SourceMapMode_1 = __webpack_require__(15); exports.NO_CUSTOM_NODES_PRESET = Object.freeze({ compact: true, + controlFlow: false, debugProtection: false, debugProtectionInterval: false, disableConsoleOutput: false, @@ -1014,6 +986,42 @@ exports.NO_CUSTOM_NODES_PRESET = Object.freeze({ unicodeEscapeSequence: true }); +/***/ }, +/* 14 */ +/***/ function(module, exports) { + +module.exports = require("escodegen"); + +/***/ }, +/* 15 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +exports.SourceMapMode = { + Inline: 'inline', + Separate: 'separate' +}; + +/***/ }, +/* 16 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var AbstractReplacer = function AbstractReplacer(nodes, options) { + _classCallCheck(this, AbstractReplacer); + + this.nodes = nodes; + this.options = options; +}; + +exports.AbstractReplacer = AbstractReplacer; + /***/ }, /* 17 */ /***/ function(module, exports, __webpack_require__) { @@ -1029,14 +1037,13 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var SingleNodeCallControllerTemplate_1 = __webpack_require__(66); -var NoCustomNodesPreset_1 = __webpack_require__(16); -var AbstractCustomNode_1 = __webpack_require__(7); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var SingleNodeCallControllerTemplate_1 = __webpack_require__(73); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var AbstractCustomNode_1 = __webpack_require__(5); var JavaScriptObfuscator_1 = __webpack_require__(10); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +var NodeAppender_1 = __webpack_require__(3); var NodeCallsControllerFunctionNode = function (_AbstractCustomNode_) { _inherits(NodeCallsControllerFunctionNode, _AbstractCustomNode_); @@ -1065,16 +1072,16 @@ var NodeCallsControllerFunctionNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.prependNode(targetBlockScope, this.getNode()); } }, { - key: 'getNodeStructure', - value: function getNodeStructure() { + key: 'getCode', + value: function getCode() { if (this.appendState === AppendState_1.AppendState.AfterObfuscation) { - return NodeUtils_1.NodeUtils.convertCodeToStructure(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(SingleNodeCallControllerTemplate_1.SingleNodeCallControllerTemplate().formatUnicorn({ + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(SingleNodeCallControllerTemplate_1.SingleNodeCallControllerTemplate().formatUnicorn({ singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode()); + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); } - return NodeUtils_1.NodeUtils.convertCodeToStructure(SingleNodeCallControllerTemplate_1.SingleNodeCallControllerTemplate().formatUnicorn({ + return SingleNodeCallControllerTemplate_1.SingleNodeCallControllerTemplate().formatUnicorn({ singleNodeCallControllerFunctionName: this.callsControllerFunctionName - })); + }); } }]); @@ -1111,7 +1118,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } var StringArrayEncoding_1 = __webpack_require__(18); -var AbstractReplacer_1 = __webpack_require__(15); +var AbstractReplacer_1 = __webpack_require__(16); var NumberLiteralReplacer_1 = __webpack_require__(22); var Utils_1 = __webpack_require__(0); @@ -1305,7 +1312,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var AbstractReplacer_1 = __webpack_require__(15); +var AbstractReplacer_1 = __webpack_require__(16); var Utils_1 = __webpack_require__(0); var NumberLiteralReplacer = function (_AbstractReplacer_1$A) { @@ -1340,9 +1347,10 @@ exports.NumberLiteralReplacer = NumberLiteralReplacer; "use strict"; "use strict"; -var SourceMapMode_1 = __webpack_require__(14); +var SourceMapMode_1 = __webpack_require__(15); exports.DEFAULT_PRESET = Object.freeze({ compact: true, + controlFlow: false, debugProtection: false, debugProtectionInterval: false, disableConsoleOutput: true, @@ -1380,6 +1388,64 @@ module.exports = require("babel-polyfill"); /***/ }, /* 27 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; })(); + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var ControlFlowStorage = function () { + function ControlFlowStorage() { + _classCallCheck(this, ControlFlowStorage); + + this.storage = new Map(); + } + + _createClass(ControlFlowStorage, [{ + key: "addToStorage", + value: function addToStorage(key, value) { + this.storage.set(key, value); + } + }, { + key: "getStorage", + value: function getStorage() { + return this.storage; + } + }, { + key: "getStorageItem", + value: function getStorageItem(key) { + var value = this.storage.get(key); + if (!value) { + throw new Error("No value found in ControlFlowStorage with key `" + key + "`"); + } + return value; + } + }, { + key: "toString", + value: function toString() { + return "{\n " + Array.from(this.storage).reduce(function (string, _ref) { + var _ref2 = _slicedToArray(_ref, 2), + key = _ref2[0], + value = _ref2[1]; + + string += key + ": " + value.getCode() + ","; + return string; + }, '') + "\n }"; + } + }]); + + return ControlFlowStorage; +}(); + +exports.ControlFlowStorage = ControlFlowStorage; + +/***/ }, +/* 28 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1390,11 +1456,11 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } var esprima = __webpack_require__(24); -var escodegen = __webpack_require__(13); +var escodegen = __webpack_require__(14); var ObfuscationResult_1 = __webpack_require__(20); -var Obfuscator_1 = __webpack_require__(28); -var Options_1 = __webpack_require__(57); -var SourceMapCorrector_1 = __webpack_require__(29); +var Obfuscator_1 = __webpack_require__(29); +var Options_1 = __webpack_require__(64); +var SourceMapCorrector_1 = __webpack_require__(30); var JavaScriptObfuscatorInternal = function () { function JavaScriptObfuscatorInternal(sourceCode) { @@ -1447,7 +1513,7 @@ JavaScriptObfuscatorInternal.escodegenParams = { exports.JavaScriptObfuscatorInternal = JavaScriptObfuscatorInternal; /***/ }, -/* 28 */ +/* 29 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1460,25 +1526,26 @@ function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } var estraverse = __webpack_require__(4); -var AppendState_1 = __webpack_require__(3); +var AppendState_1 = __webpack_require__(1); var NodeType_1 = __webpack_require__(6); -var CatchClauseObfuscator_1 = __webpack_require__(47); -var ConsoleOutputNodesGroup_1 = __webpack_require__(42); -var DebugProtectionNodesGroup_1 = __webpack_require__(43); -var DomainLockNodesGroup_1 = __webpack_require__(44); -var FunctionDeclarationObfuscator_1 = __webpack_require__(48); -var FunctionObfuscator_1 = __webpack_require__(49); -var LabeledStatementObfuscator_1 = __webpack_require__(50); -var LiteralObfuscator_1 = __webpack_require__(51); -var MemberExpressionObfuscator_1 = __webpack_require__(52); -var MethodDefinitionObfuscator_1 = __webpack_require__(53); +var CatchClauseObfuscator_1 = __webpack_require__(54); +var ConsoleOutputNodesGroup_1 = __webpack_require__(49); +var DebugProtectionNodesGroup_1 = __webpack_require__(50); +var DomainLockNodesGroup_1 = __webpack_require__(51); +var FunctionDeclarationObfuscator_1 = __webpack_require__(55); +var FunctionObfuscator_1 = __webpack_require__(56); +var LabeledStatementObfuscator_1 = __webpack_require__(57); +var LiteralObfuscator_1 = __webpack_require__(58); +var MemberExpressionObfuscator_1 = __webpack_require__(59); +var MethodDefinitionObfuscator_1 = __webpack_require__(60); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); -var ObjectExpressionObfuscator_1 = __webpack_require__(54); -var SelfDefendingNodesGroup_1 = __webpack_require__(45); -var StackTraceAnalyzer_1 = __webpack_require__(60); -var StringArrayNodesGroup_1 = __webpack_require__(46); -var VariableDeclarationObfuscator_1 = __webpack_require__(55); +var NodeUtils_1 = __webpack_require__(7); +var ObjectExpressionObfuscator_1 = __webpack_require__(61); +var SelfDefendingNodesGroup_1 = __webpack_require__(52); +var StackTraceAnalyzer_1 = __webpack_require__(67); +var StringArrayNodesGroup_1 = __webpack_require__(53); +var VariableDeclarationObfuscator_1 = __webpack_require__(62); +var FunctionControlFlowChanger_1 = __webpack_require__(46); var Obfuscator = function () { function Obfuscator(options) { @@ -1500,6 +1567,9 @@ var Obfuscator = function () { this.beforeObfuscation(node); this.obfuscate(node); this.afterObfuscation(node); + if (this.options.controlFlow) { + this.changeControlFlow(node); + } return node; } }, { @@ -1520,14 +1590,25 @@ var Obfuscator = function () { } }); } + }, { + key: 'changeControlFlow', + value: function changeControlFlow(node) { + var _this = this; + + estraverse.traverse(node, { + leave: function leave(node, parentNode) { + _this.initializeNodeControlFlowChangers(node, parentNode); + } + }); + } }, { key: 'initializeCustomNodes', value: function initializeCustomNodes(stackTraceData) { - var _this = this; + var _this2 = this; var customNodes = []; Obfuscator.nodeGroups.forEach(function (nodeGroupConstructor) { - var nodeGroupNodes = new nodeGroupConstructor(stackTraceData, _this.options).getNodes(); + var nodeGroupNodes = new nodeGroupConstructor(stackTraceData, _this2.options).getNodes(); if (!nodeGroupNodes) { return; } @@ -1535,27 +1616,40 @@ var Obfuscator = function () { }); this.customNodes = new Map(customNodes); } + }, { + key: 'initializeNodeControlFlowChangers', + value: function initializeNodeControlFlowChangers(node, parentNode) { + var _this3 = this; + + var nodeControlFlowChangers = Obfuscator.nodeControlFlowChangers.get(node.type); + if (!nodeControlFlowChangers) { + return; + } + nodeControlFlowChangers.forEach(function (controlFlowChanger) { + new controlFlowChanger(_this3.customNodes, _this3.options).changeControlFlow(node, parentNode); + }); + } }, { key: 'initializeNodeObfuscators', value: function initializeNodeObfuscators(node, parentNode) { - var _this2 = this; + var _this4 = this; var nodeObfuscators = Obfuscator.nodeObfuscators.get(node.type); if (!nodeObfuscators) { return; } nodeObfuscators.forEach(function (obfuscator) { - new obfuscator(_this2.customNodes, _this2.options).obfuscateNode(node, parentNode); + new obfuscator(_this4.customNodes, _this4.options).obfuscateNode(node, parentNode); }); } }, { key: 'obfuscate', value: function obfuscate(node) { - var _this3 = this; + var _this5 = this; estraverse.traverse(node, { enter: function enter(node, parentNode) { - _this3.initializeNodeObfuscators(node, parentNode); + _this5.initializeNodeObfuscators(node, parentNode); } }); } @@ -1564,12 +1658,13 @@ var Obfuscator = function () { return Obfuscator; }(); +Obfuscator.nodeControlFlowChangers = new Map([[NodeType_1.NodeType.FunctionDeclaration, [FunctionControlFlowChanger_1.FunctionControlFlowChanger]], [NodeType_1.NodeType.FunctionExpression, [FunctionControlFlowChanger_1.FunctionControlFlowChanger]]]); Obfuscator.nodeGroups = [DomainLockNodesGroup_1.DomainLockNodesGroup, SelfDefendingNodesGroup_1.SelfDefendingNodesGroup, ConsoleOutputNodesGroup_1.ConsoleOutputNodesGroup, DebugProtectionNodesGroup_1.DebugProtectionNodesGroup, StringArrayNodesGroup_1.StringArrayNodesGroup]; Obfuscator.nodeObfuscators = new Map([[NodeType_1.NodeType.ArrowFunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.ClassDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator]], [NodeType_1.NodeType.CatchClause, [CatchClauseObfuscator_1.CatchClauseObfuscator]], [NodeType_1.NodeType.FunctionDeclaration, [FunctionDeclarationObfuscator_1.FunctionDeclarationObfuscator, FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.FunctionExpression, [FunctionObfuscator_1.FunctionObfuscator]], [NodeType_1.NodeType.MemberExpression, [MemberExpressionObfuscator_1.MemberExpressionObfuscator]], [NodeType_1.NodeType.MethodDefinition, [MethodDefinitionObfuscator_1.MethodDefinitionObfuscator]], [NodeType_1.NodeType.ObjectExpression, [ObjectExpressionObfuscator_1.ObjectExpressionObfuscator]], [NodeType_1.NodeType.VariableDeclaration, [VariableDeclarationObfuscator_1.VariableDeclarationObfuscator]], [NodeType_1.NodeType.LabeledStatement, [LabeledStatementObfuscator_1.LabeledStatementObfuscator]], [NodeType_1.NodeType.Literal, [LiteralObfuscator_1.LiteralObfuscator]]]); exports.Obfuscator = Obfuscator; /***/ }, -/* 29 */ +/* 30 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1579,7 +1674,7 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var SourceMapMode_1 = __webpack_require__(14); +var SourceMapMode_1 = __webpack_require__(15); var ObfuscationResult_1 = __webpack_require__(20); var Utils_1 = __webpack_require__(0); @@ -1627,7 +1722,7 @@ var SourceMapCorrector = function () { exports.SourceMapCorrector = SourceMapCorrector; /***/ }, -/* 30 */ +/* 31 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1686,7 +1781,7 @@ var StringArray = function () { exports.StringArray = StringArray; /***/ }, -/* 31 */ +/* 32 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1696,8 +1791,8 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var fs = __webpack_require__(85); -var mkdirp = __webpack_require__(86); +var fs = __webpack_require__(94); +var mkdirp = __webpack_require__(95); var path = __webpack_require__(25); var Utils_1 = __webpack_require__(0); @@ -1778,7 +1873,7 @@ CLIUtils.encoding = 'utf8'; exports.CLIUtils = CLIUtils; /***/ }, -/* 32 */ +/* 33 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1788,12 +1883,12 @@ var _createClass = (function () { function defineProperties(target, props) { for function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } -var commander = __webpack_require__(84); +var commander = __webpack_require__(93); var path = __webpack_require__(25); -var SourceMapMode_1 = __webpack_require__(14); +var SourceMapMode_1 = __webpack_require__(15); var StringArrayEncoding_1 = __webpack_require__(18); var DefaultPreset_1 = __webpack_require__(23); -var CLIUtils_1 = __webpack_require__(31); +var CLIUtils_1 = __webpack_require__(32); var JavaScriptObfuscator_1 = __webpack_require__(10); var Utils_1 = __webpack_require__(0); @@ -1926,7 +2021,7 @@ var JavaScriptObfuscatorCLI = function () { exports.JavaScriptObfuscatorCLI = JavaScriptObfuscatorCLI; /***/ }, -/* 33 */ +/* 34 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1940,12 +2035,11 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var ConsoleOutputDisableExpressionTemplate_1 = __webpack_require__(67); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var ConsoleOutputDisableExpressionTemplate_1 = __webpack_require__(74); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var ConsoleOutputDisableExpressionNode = function (_AbstractCustomNode_) { @@ -1969,12 +2063,12 @@ var ConsoleOutputDisableExpressionNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.appendNodeToOptimalBlockScope(this.stackTraceData, blockScopeNode, this.getNode(), this.randomStackTraceIndex); } }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - return NodeUtils_1.NodeUtils.convertCodeToStructure(ConsoleOutputDisableExpressionTemplate_1.ConsoleOutputDisableExpressionTemplate().formatUnicorn({ + key: 'getCode', + value: function getCode() { + return ConsoleOutputDisableExpressionTemplate_1.ConsoleOutputDisableExpressionTemplate().formatUnicorn({ consoleLogDisableFunctionName: Utils_1.Utils.getRandomVariableName(), singleNodeCallControllerFunctionName: this.callsControllerFunctionName - })); + }); } }]); @@ -1984,7 +2078,7 @@ var ConsoleOutputDisableExpressionNode = function (_AbstractCustomNode_) { exports.ConsoleOutputDisableExpressionNode = ConsoleOutputDisableExpressionNode; /***/ }, -/* 34 */ +/* 35 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -1998,12 +2092,133 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var DebufProtectionFunctionCallTemplate_1 = __webpack_require__(68); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var BinaryExpressionSumFunctionTemplate_1 = __webpack_require__(75); +var AbstractCustomNode_1 = __webpack_require__(5); +var JavaScriptObfuscator_1 = __webpack_require__(10); +var Utils_1 = __webpack_require__(0); + +var BinaryExpressionSumFunctionNode = function (_AbstractCustomNode_) { + _inherits(BinaryExpressionSumFunctionNode, _AbstractCustomNode_); + + function BinaryExpressionSumFunctionNode() { + _classCallCheck(this, BinaryExpressionSumFunctionNode); + + var _this = _possibleConstructorReturn(this, (BinaryExpressionSumFunctionNode.__proto__ || Object.getPrototypeOf(BinaryExpressionSumFunctionNode)).apply(this, arguments)); + + _this.appendState = AppendState_1.AppendState.BeforeObfuscation; + return _this; + } + + _createClass(BinaryExpressionSumFunctionNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) {} + }, { + key: 'getCode', + value: function getCode() { + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(BinaryExpressionSumFunctionTemplate_1.BinaryExpressionSumFunctionTemplate().formatUnicorn({ + functionName: Utils_1.Utils.getRandomVariableName() + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); + } + }]); + + return BinaryExpressionSumFunctionNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.BinaryExpressionSumFunctionNode = BinaryExpressionSumFunctionNode; + +/***/ }, +/* 36 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var ControlFlowStorageTemplate_1 = __webpack_require__(76); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); + +var ControlFlowStorageNode = function (_AbstractCustomNode_) { + _inherits(ControlFlowStorageNode, _AbstractCustomNode_); + + function ControlFlowStorageNode(controlFlowStorage, controlFlowStorageName, options) { + _classCallCheck(this, ControlFlowStorageNode); + + var _this = _possibleConstructorReturn(this, (ControlFlowStorageNode.__proto__ || Object.getPrototypeOf(ControlFlowStorageNode)).call(this, options)); + + _this.appendState = AppendState_1.AppendState.AfterObfuscation; + _this.controlFlowStorage = controlFlowStorage; + _this.controlFlowStorageName = controlFlowStorageName; + return _this; + } + + _createClass(ControlFlowStorageNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) { + NodeAppender_1.NodeAppender.prependNode(blockScopeNode, this.getNode()); + } + }, { + key: 'getCode', + value: function getCode() { + return ControlFlowStorageTemplate_1.ControlFlowStorageTemplate().formatUnicorn({ + controlFlowStorage: this.controlFlowStorage.toString(), + controlFlowStorageName: this.controlFlowStorageName + }); + } + }, { + key: 'getNodeIdentifier', + value: function getNodeIdentifier() { + return this.controlFlowStorageName; + } + }, { + key: 'getNodeData', + value: function getNodeData() { + return this.controlFlowStorage; + } + }, { + key: 'updateNodeData', + value: function updateNodeData(key, value) { + this.controlFlowStorage.addToStorage(key, value); + } + }]); + + return ControlFlowStorageNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.ControlFlowStorageNode = ControlFlowStorageNode; + +/***/ }, +/* 37 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var DebufProtectionFunctionCallTemplate_1 = __webpack_require__(77); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var DebugProtectionFunctionCallNode = function (_AbstractCustomNode_) { _inherits(DebugProtectionFunctionCallNode, _AbstractCustomNode_); @@ -2024,11 +2239,11 @@ var DebugProtectionFunctionCallNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.appendNode(blockScopeNode, this.getNode()); } }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - return NodeUtils_1.NodeUtils.convertCodeToStructure(DebufProtectionFunctionCallTemplate_1.DebugProtectionFunctionCallTemplate().formatUnicorn({ + key: 'getCode', + value: function getCode() { + return DebufProtectionFunctionCallTemplate_1.DebugProtectionFunctionCallTemplate().formatUnicorn({ debugProtectionFunctionName: this.debugProtectionFunctionName - })); + }); } }]); @@ -2038,7 +2253,7 @@ var DebugProtectionFunctionCallNode = function (_AbstractCustomNode_) { exports.DebugProtectionFunctionCallNode = DebugProtectionFunctionCallNode; /***/ }, -/* 35 */ +/* 38 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2052,12 +2267,11 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var DebugProtectionFunctionIntervalTemplate_1 = __webpack_require__(69); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var DebugProtectionFunctionIntervalTemplate_1 = __webpack_require__(78); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var DebugProtectionFunctionIntervalNode = function (_AbstractCustomNode_) { _inherits(DebugProtectionFunctionIntervalNode, _AbstractCustomNode_); @@ -2078,11 +2292,11 @@ var DebugProtectionFunctionIntervalNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.appendNode(blockScopeNode, this.getNode()); } }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - return NodeUtils_1.NodeUtils.convertCodeToStructure(DebugProtectionFunctionIntervalTemplate_1.DebugProtectionFunctionIntervalTemplate().formatUnicorn({ + key: 'getCode', + value: function getCode() { + return DebugProtectionFunctionIntervalTemplate_1.DebugProtectionFunctionIntervalTemplate().formatUnicorn({ debugProtectionFunctionName: this.debugProtectionFunctionName - })); + }); } }]); @@ -2092,7 +2306,7 @@ var DebugProtectionFunctionIntervalNode = function (_AbstractCustomNode_) { exports.DebugProtectionFunctionIntervalNode = DebugProtectionFunctionIntervalNode; /***/ }, -/* 36 */ +/* 39 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2106,12 +2320,11 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var DebugProtectionFunctionTemplate_1 = __webpack_require__(70); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var DebugProtectionFunctionTemplate_1 = __webpack_require__(79); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var DebugProtectionFunctionNode = function (_AbstractCustomNode_) { @@ -2137,18 +2350,18 @@ var DebugProtectionFunctionNode = function (_AbstractCustomNode_) { }); NodeAppender_1.NodeAppender.insertNodeAtIndex(blockScopeNode, this.getNode(), randomIndex); } + }, { + key: 'getCode', + value: function getCode() { + return DebugProtectionFunctionTemplate_1.DebugProtectionFunctionTemplate().formatUnicorn({ + debugProtectionFunctionName: this.debugProtectionFunctionName + }); + } }, { key: 'getNodeIdentifier', value: function getNodeIdentifier() { return this.debugProtectionFunctionName; } - }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - return NodeUtils_1.NodeUtils.convertCodeToStructure(DebugProtectionFunctionTemplate_1.DebugProtectionFunctionTemplate().formatUnicorn({ - debugProtectionFunctionName: this.debugProtectionFunctionName - })); - } }]); return DebugProtectionFunctionNode; @@ -2157,7 +2370,7 @@ var DebugProtectionFunctionNode = function (_AbstractCustomNode_) { exports.DebugProtectionFunctionNode = DebugProtectionFunctionNode; /***/ }, -/* 37 */ +/* 40 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2173,12 +2386,11 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var DomainLockNodeTemplate_1 = __webpack_require__(71); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var DomainLockNodeTemplate_1 = __webpack_require__(80); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var DomainLockNode = function (_AbstractCustomNode_) { @@ -2202,19 +2414,19 @@ var DomainLockNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.appendNodeToOptimalBlockScope(this.stackTraceData, blockScopeNode, this.getNode(), this.randomStackTraceIndex); } }, { - key: 'getNodeStructure', - value: function getNodeStructure() { + key: 'getCode', + value: function getCode() { var domainsString = this.options.domainLock.join(';'), _Utils_1$Utils$hideSt = Utils_1.Utils.hideString(domainsString, domainsString.length * 3), _Utils_1$Utils$hideSt2 = _slicedToArray(_Utils_1$Utils$hideSt, 2), hiddenDomainsString = _Utils_1$Utils$hideSt2[0], diff = _Utils_1$Utils$hideSt2[1]; - return NodeUtils_1.NodeUtils.convertCodeToStructure(DomainLockNodeTemplate_1.DomainLockNodeTemplate().formatUnicorn({ + return DomainLockNodeTemplate_1.DomainLockNodeTemplate().formatUnicorn({ domainLockFunctionName: Utils_1.Utils.getRandomVariableName(), diff: diff, domains: hiddenDomainsString, singleNodeCallControllerFunctionName: this.callsControllerFunctionName - })); + }); } }]); @@ -2224,7 +2436,7 @@ var DomainLockNode = function (_AbstractCustomNode_) { exports.DomainLockNode = DomainLockNode; /***/ }, -/* 38 */ +/* 41 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2238,13 +2450,12 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var AppendState_1 = __webpack_require__(3); -var NoCustomNodesPreset_1 = __webpack_require__(16); -var SelfDefendingTemplate_1 = __webpack_require__(72); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var SelfDefendingTemplate_1 = __webpack_require__(81); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var JavaScriptObfuscator_1 = __webpack_require__(10); -var NodeUtils_1 = __webpack_require__(1); var Utils_1 = __webpack_require__(0); var SelfDefendingUnicodeNode = function (_AbstractCustomNode_) { @@ -2268,12 +2479,12 @@ var SelfDefendingUnicodeNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.appendNodeToOptimalBlockScope(this.stackTraceData, blockScopeNode, this.getNode(), this.randomStackTraceIndex); } }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - return NodeUtils_1.NodeUtils.convertCodeToStructure(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(SelfDefendingTemplate_1.SelfDefendingTemplate().formatUnicorn({ + key: 'getCode', + value: function getCode() { + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(SelfDefendingTemplate_1.SelfDefendingTemplate().formatUnicorn({ selfDefendingFunctionName: Utils_1.Utils.getRandomVariableName(), singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode()); + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); } }]); @@ -2283,7 +2494,7 @@ var SelfDefendingUnicodeNode = function (_AbstractCustomNode_) { exports.SelfDefendingUnicodeNode = SelfDefendingUnicodeNode; /***/ }, -/* 39 */ +/* 42 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2299,20 +2510,19 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); var StringArrayEncoding_1 = __webpack_require__(18); -var NoCustomNodesPreset_1 = __webpack_require__(16); -var AtobTemplate_1 = __webpack_require__(64); -var Rc4Template_1 = __webpack_require__(65); -var SelfDefendingTemplate_1 = __webpack_require__(73); -var StringArrayBase64DecodeNodeTemplate_1 = __webpack_require__(74); -var StringArrayCallsWrapperTemplate_1 = __webpack_require__(75); -var StringArrayRC4DecodeNodeTemplate_1 = __webpack_require__(76); -var AbstractCustomNode_1 = __webpack_require__(7); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var AtobTemplate_1 = __webpack_require__(71); +var Rc4Template_1 = __webpack_require__(72); +var SelfDefendingTemplate_1 = __webpack_require__(82); +var StringArrayBase64DecodeNodeTemplate_1 = __webpack_require__(83); +var StringArrayCallsWrapperTemplate_1 = __webpack_require__(84); +var StringArrayRC4DecodeNodeTemplate_1 = __webpack_require__(85); +var AbstractCustomNode_1 = __webpack_require__(5); var JavaScriptObfuscator_1 = __webpack_require__(10); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +var NodeAppender_1 = __webpack_require__(3); var StringArrayCallsWrapper = function (_AbstractCustomNode_) { _inherits(StringArrayCallsWrapper, _AbstractCustomNode_); @@ -2337,6 +2547,16 @@ var StringArrayCallsWrapper = function (_AbstractCustomNode_) { } NodeAppender_1.NodeAppender.insertNodeAtIndex(blockScopeNode, this.getNode(), 1); } + }, { + key: 'getCode', + value: function getCode() { + var decodeNodeTemplate = this.getDecodeStringArrayTemplate(); + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(StringArrayCallsWrapperTemplate_1.StringArrayCallsWrapperTemplate().formatUnicorn({ + decodeNodeTemplate: decodeNodeTemplate, + stringArrayCallsWrapperName: this.stringArrayCallsWrapperName, + stringArrayName: this.stringArrayName + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); + } }, { key: 'getNodeIdentifier', value: function getNodeIdentifier() { @@ -2377,16 +2597,6 @@ var StringArrayCallsWrapper = function (_AbstractCustomNode_) { } return decodeStringArrayTemplate; } - }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - var decodeNodeTemplate = this.getDecodeStringArrayTemplate(); - return NodeUtils_1.NodeUtils.convertCodeToStructure(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(StringArrayCallsWrapperTemplate_1.StringArrayCallsWrapperTemplate().formatUnicorn({ - decodeNodeTemplate: decodeNodeTemplate, - stringArrayCallsWrapperName: this.stringArrayCallsWrapperName, - stringArrayName: this.stringArrayName - }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode()); - } }]); return StringArrayCallsWrapper; @@ -2395,7 +2605,7 @@ var StringArrayCallsWrapper = function (_AbstractCustomNode_) { exports.StringArrayCallsWrapper = StringArrayCallsWrapper; /***/ }, -/* 40 */ +/* 43 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2411,12 +2621,11 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var StringArrayTemplate_1 = __webpack_require__(77); -var AbstractCustomNode_1 = __webpack_require__(7); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var StringArrayTemplate_1 = __webpack_require__(86); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var StringArrayNode = function (_AbstractCustomNode_) { _inherits(StringArrayNode, _AbstractCustomNode_); @@ -2444,6 +2653,14 @@ var StringArrayNode = function (_AbstractCustomNode_) { } NodeAppender_1.NodeAppender.prependNode(blockScopeNode, this.getNode()); } + }, { + key: 'getCode', + value: function getCode() { + return StringArrayTemplate_1.StringArrayTemplate().formatUnicorn({ + stringArrayName: this.stringArrayName, + stringArray: this.stringArray.toString() + }); + } }, { key: 'getNodeIdentifier', value: function getNodeIdentifier() { @@ -2465,14 +2682,6 @@ var StringArrayNode = function (_AbstractCustomNode_) { value: function updateNodeData(data) { this.stringArray.addToArray(data); } - }, { - key: 'getNodeStructure', - value: function getNodeStructure() { - return NodeUtils_1.NodeUtils.convertCodeToStructure(StringArrayTemplate_1.StringArrayTemplate().formatUnicorn({ - stringArrayName: this.stringArrayName, - stringArray: this.stringArray.toString() - })); - } }]); return StringArrayNode; @@ -2482,7 +2691,7 @@ StringArrayNode.ARRAY_RANDOM_LENGTH = 4; exports.StringArrayNode = StringArrayNode; /***/ }, -/* 41 */ +/* 44 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2490,23 +2699,20 @@ exports.StringArrayNode = StringArrayNode; var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); -var _get = (function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }); - function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -__webpack_require__(9); -var AppendState_1 = __webpack_require__(3); -var NoCustomNodesPreset_1 = __webpack_require__(16); -var SelfDefendingTemplate_1 = __webpack_require__(78); -var StringArrayRotateFunctionTemplate_1 = __webpack_require__(79); -var AbstractCustomNode_1 = __webpack_require__(7); +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var SelfDefendingTemplate_1 = __webpack_require__(87); +var StringArrayRotateFunctionTemplate_1 = __webpack_require__(88); +var AbstractCustomNode_1 = __webpack_require__(5); var JavaScriptObfuscator_1 = __webpack_require__(10); -var NodeAppender_1 = __webpack_require__(5); -var NodeUtils_1 = __webpack_require__(1); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var StringArrayRotateFunctionNode = function (_AbstractCustomNode_) { @@ -2533,13 +2739,8 @@ var StringArrayRotateFunctionNode = function (_AbstractCustomNode_) { NodeAppender_1.NodeAppender.insertNodeAtIndex(blockScopeNode, this.getNode(), 1); } }, { - key: 'getNode', - value: function getNode() { - return _get(StringArrayRotateFunctionNode.prototype.__proto__ || Object.getPrototypeOf(StringArrayRotateFunctionNode.prototype), 'getNode', this).call(this); - } - }, { - key: 'getNodeStructure', - value: function getNodeStructure() { + key: 'getCode', + value: function getCode() { var code = '', timesName = Utils_1.Utils.getRandomVariableName(), whileFunctionName = Utils_1.Utils.getRandomVariableName(); @@ -2551,13 +2752,13 @@ var StringArrayRotateFunctionNode = function (_AbstractCustomNode_) { } else { code = whileFunctionName + '(++' + timesName + ')'; } - return NodeUtils_1.NodeUtils.convertCodeToStructure(JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(StringArrayRotateFunctionTemplate_1.StringArrayRotateFunctionTemplate().formatUnicorn({ + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(StringArrayRotateFunctionTemplate_1.StringArrayRotateFunctionTemplate().formatUnicorn({ code: code, timesName: timesName, stringArrayName: this.stringArrayName, stringArrayRotateValue: Utils_1.Utils.decToHex(this.stringArrayRotateValue), whileFunctionName: whileFunctionName - }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode()); + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); } }]); @@ -2567,7 +2768,25 @@ var StringArrayRotateFunctionNode = function (_AbstractCustomNode_) { exports.StringArrayRotateFunctionNode = StringArrayRotateFunctionNode; /***/ }, -/* 42 */ +/* 45 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var AbstractNodeControlFlowChanger = function AbstractNodeControlFlowChanger(nodes, options) { + _classCallCheck(this, AbstractNodeControlFlowChanger); + + this.nodes = nodes; + this.options = options; +}; + +exports.AbstractNodeControlFlowChanger = AbstractNodeControlFlowChanger; + +/***/ }, +/* 46 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2581,10 +2800,193 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var ConsoleOutputDisableExpressionNode_1 = __webpack_require__(33); +var estraverse = __webpack_require__(4); +var NodeType_1 = __webpack_require__(6); +var AbstractNodeControlFlowChanger_1 = __webpack_require__(45); +var BinaryExpressionControlFlowReplacer_1 = __webpack_require__(48); +var ControlFlowStorage_1 = __webpack_require__(27); +var ControlFlowStorageNode_1 = __webpack_require__(36); +var Node_1 = __webpack_require__(2); +var NodeAppender_1 = __webpack_require__(3); +var Utils_1 = __webpack_require__(0); + +var FunctionControlFlowChanger = function (_AbstractNodeControlF) { + _inherits(FunctionControlFlowChanger, _AbstractNodeControlF); + + function FunctionControlFlowChanger(nodes, options) { + _classCallCheck(this, FunctionControlFlowChanger); + + return _possibleConstructorReturn(this, (FunctionControlFlowChanger.__proto__ || Object.getPrototypeOf(FunctionControlFlowChanger)).call(this, nodes, options)); + } + + _createClass(FunctionControlFlowChanger, [{ + key: 'changeControlFlow', + value: function changeControlFlow(functionNode) { + this.changeFunctionBodyControlFlow(functionNode); + } + }, { + key: 'changeFunctionBodyControlFlow', + value: function changeFunctionBodyControlFlow(functionNode) { + var _this2 = this; + + var controlFlowStorage = new ControlFlowStorage_1.ControlFlowStorage(); + var controlFlowStorageCustomNodeName = Utils_1.Utils.getRandomVariableName(6); + if (!Node_1.Node.isFunctionDeclarationNode(functionNode) && !Node_1.Node.isFunctionExpressionNode(functionNode)) { + return; + } + estraverse.replace(functionNode.body, { + enter: function enter(node, parentNode) { + var controlFlowReplacerConstructor = FunctionControlFlowChanger.controlFlowReplacers.get(node.type); + if (!controlFlowReplacerConstructor) { + return; + } + var controlFlowStorageCallCustomNode = new controlFlowReplacerConstructor(_this2.nodes, _this2.options).replace(node, parentNode, controlFlowStorage, controlFlowStorageCustomNodeName); + if (!controlFlowStorageCallCustomNode) { + return; + } + return controlFlowStorageCallCustomNode.getNode()[0].expression; + } + }); + var controlFlowStorageCustomNode = new ControlFlowStorageNode_1.ControlFlowStorageNode(controlFlowStorage, controlFlowStorageCustomNodeName, this.options); + NodeAppender_1.NodeAppender.prependNode(functionNode.body, controlFlowStorageCustomNode.getNode()); + } + }]); + + return FunctionControlFlowChanger; +}(AbstractNodeControlFlowChanger_1.AbstractNodeControlFlowChanger); + +FunctionControlFlowChanger.controlFlowReplacers = new Map([[NodeType_1.NodeType.BinaryExpression, BinaryExpressionControlFlowReplacer_1.BinaryExpressionControlFlowReplacer]]); +exports.FunctionControlFlowChanger = FunctionControlFlowChanger; + +/***/ }, +/* 47 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Utils_1 = __webpack_require__(0); + +var AbstractControlFlowReplacer = function () { + function AbstractControlFlowReplacer(nodes, options) { + _classCallCheck(this, AbstractControlFlowReplacer); + + this.nodes = nodes; + this.options = options; + } + + _createClass(AbstractControlFlowReplacer, null, [{ + key: 'getStorageKey', + value: function getStorageKey() { + return Utils_1.Utils.getRandomGenerator().string({ + length: 3, + pool: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' + }); + } + }]); + + return AbstractControlFlowReplacer; +}(); + +exports.AbstractControlFlowReplacer = AbstractControlFlowReplacer; + +/***/ }, +/* 48 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var escodegen = __webpack_require__(14); +var AbstractControlFlowReplacer_1 = __webpack_require__(47); +var BinaryExpressionSumFunctionNode_1 = __webpack_require__(35); +var BinaryExpressionSubtractFunctionNode_1 = __webpack_require__(103); +var BinaryExpressionMultiplyFunctionNode_1 = __webpack_require__(102); +var BinaryExpressionDivideFunctionNode_1 = __webpack_require__(100); +var BinaryExpressionExponentiationFunctionNode_1 = __webpack_require__(101); +var ControlFlowStorageCallNode_1 = __webpack_require__(98); + +var BinaryExpressionControlFlowReplacer = function (_AbstractControlFlowR) { + _inherits(BinaryExpressionControlFlowReplacer, _AbstractControlFlowR); + + function BinaryExpressionControlFlowReplacer() { + _classCallCheck(this, BinaryExpressionControlFlowReplacer); + + return _possibleConstructorReturn(this, (BinaryExpressionControlFlowReplacer.__proto__ || Object.getPrototypeOf(BinaryExpressionControlFlowReplacer)).apply(this, arguments)); + } + + _createClass(BinaryExpressionControlFlowReplacer, [{ + key: 'replace', + value: function replace(binaryExpressionNode, parentNode, controlFlowStorage, controlFlowStorageCustomNodeName) { + var binaryExpressionFunctionNode = void 0; + switch (binaryExpressionNode.operator) { + case '+': + binaryExpressionFunctionNode = new BinaryExpressionSumFunctionNode_1.BinaryExpressionSumFunctionNode(this.options); + break; + case '-': + binaryExpressionFunctionNode = new BinaryExpressionSubtractFunctionNode_1.BinaryExpressionSubtractFunctionNode(this.options); + break; + case '*': + binaryExpressionFunctionNode = new BinaryExpressionMultiplyFunctionNode_1.BinaryExpressionMultiplyFunctionNode(this.options); + break; + case '/': + binaryExpressionFunctionNode = new BinaryExpressionDivideFunctionNode_1.BinaryExpressionDivideFunctionNode(this.options); + break; + case '**': + binaryExpressionFunctionNode = new BinaryExpressionExponentiationFunctionNode_1.BinaryExpressionExponentiationFunctionNode(this.options); + break; + default: + return; + } + var key = AbstractControlFlowReplacer_1.AbstractControlFlowReplacer.getStorageKey(); + controlFlowStorage.addToStorage(key, binaryExpressionFunctionNode); + return new ControlFlowStorageCallNode_1.ControlFlowStorageCallNode(controlFlowStorageCustomNodeName, key, BinaryExpressionControlFlowReplacer.getExpressionValue(binaryExpressionNode.left), BinaryExpressionControlFlowReplacer.getExpressionValue(binaryExpressionNode.right), this.options); + } + }], [{ + key: 'getExpressionValue', + value: function getExpressionValue(expressionNode) { + return escodegen.generate(expressionNode, { + sourceMapWithCode: true + }).code; + } + }]); + + return BinaryExpressionControlFlowReplacer; +}(AbstractControlFlowReplacer_1.AbstractControlFlowReplacer); + +exports.BinaryExpressionControlFlowReplacer = BinaryExpressionControlFlowReplacer; + +/***/ }, +/* 49 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var ConsoleOutputDisableExpressionNode_1 = __webpack_require__(34); var NodeCallsControllerFunctionNode_1 = __webpack_require__(17); var AbstractNodesGroup_1 = __webpack_require__(11); -var NodeAppender_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var ConsoleOutputNodesGroup = function (_AbstractNodesGroup_) { @@ -2614,7 +3016,7 @@ var ConsoleOutputNodesGroup = function (_AbstractNodesGroup_) { exports.ConsoleOutputNodesGroup = ConsoleOutputNodesGroup; /***/ }, -/* 43 */ +/* 50 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2628,9 +3030,9 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var DebugProtectionFunctionCallNode_1 = __webpack_require__(34); -var DebugProtectionFunctionIntervalNode_1 = __webpack_require__(35); -var DebugProtectionFunctionNode_1 = __webpack_require__(36); +var DebugProtectionFunctionCallNode_1 = __webpack_require__(37); +var DebugProtectionFunctionIntervalNode_1 = __webpack_require__(38); +var DebugProtectionFunctionNode_1 = __webpack_require__(39); var AbstractNodesGroup_1 = __webpack_require__(11); var Utils_1 = __webpack_require__(0); @@ -2664,7 +3066,7 @@ var DebugProtectionNodesGroup = function (_AbstractNodesGroup_) { exports.DebugProtectionNodesGroup = DebugProtectionNodesGroup; /***/ }, -/* 44 */ +/* 51 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2678,10 +3080,10 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var DomainLockNode_1 = __webpack_require__(37); +var DomainLockNode_1 = __webpack_require__(40); var NodeCallsControllerFunctionNode_1 = __webpack_require__(17); var AbstractNodesGroup_1 = __webpack_require__(11); -var NodeAppender_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var DomainLockNodesGroup = function (_AbstractNodesGroup_) { @@ -2711,7 +3113,7 @@ var DomainLockNodesGroup = function (_AbstractNodesGroup_) { exports.DomainLockNodesGroup = DomainLockNodesGroup; /***/ }, -/* 45 */ +/* 52 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2725,11 +3127,11 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var AppendState_1 = __webpack_require__(3); +var AppendState_1 = __webpack_require__(1); var NodeCallsControllerFunctionNode_1 = __webpack_require__(17); -var SelfDefendingUnicodeNode_1 = __webpack_require__(38); +var SelfDefendingUnicodeNode_1 = __webpack_require__(41); var AbstractNodesGroup_1 = __webpack_require__(11); -var NodeAppender_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); var Utils_1 = __webpack_require__(0); var SelfDefendingNodesGroup = function (_AbstractNodesGroup_) { @@ -2762,7 +3164,7 @@ var SelfDefendingNodesGroup = function (_AbstractNodesGroup_) { exports.SelfDefendingNodesGroup = SelfDefendingNodesGroup; /***/ }, -/* 46 */ +/* 53 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2776,12 +3178,12 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var AppendState_1 = __webpack_require__(3); -var StringArrayCallsWrapper_1 = __webpack_require__(39); -var StringArrayNode_1 = __webpack_require__(40); -var StringArrayRotateFunctionNode_1 = __webpack_require__(41); +var AppendState_1 = __webpack_require__(1); +var StringArrayCallsWrapper_1 = __webpack_require__(42); +var StringArrayNode_1 = __webpack_require__(43); +var StringArrayRotateFunctionNode_1 = __webpack_require__(44); var AbstractNodesGroup_1 = __webpack_require__(11); -var StringArray_1 = __webpack_require__(30); +var StringArray_1 = __webpack_require__(31); var Utils_1 = __webpack_require__(0); var StringArrayNodesGroup = function (_AbstractNodesGroup_) { @@ -2828,7 +3230,7 @@ var StringArrayNodesGroup = function (_AbstractNodesGroup_) { exports.StringArrayNodesGroup = StringArrayNodesGroup; /***/ }, -/* 47 */ +/* 54 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2844,10 +3246,10 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function" var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var IdentifierReplacer_1 = __webpack_require__(12); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var CatchClauseObfuscator = function (_AbstractNodeObfuscat) { _inherits(CatchClauseObfuscator, _AbstractNodeObfuscat); @@ -2899,7 +3301,7 @@ var CatchClauseObfuscator = function (_AbstractNodeObfuscat) { exports.CatchClauseObfuscator = CatchClauseObfuscator; /***/ }, -/* 48 */ +/* 55 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2915,10 +3317,10 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function" var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var IdentifierReplacer_1 = __webpack_require__(12); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var FunctionDeclarationObfuscator = function (_AbstractNodeObfuscat) { _inherits(FunctionDeclarationObfuscator, _AbstractNodeObfuscat); @@ -2974,7 +3376,7 @@ var FunctionDeclarationObfuscator = function (_AbstractNodeObfuscat) { exports.FunctionDeclarationObfuscator = FunctionDeclarationObfuscator; /***/ }, -/* 49 */ +/* 56 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -2990,10 +3392,10 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function" var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var IdentifierReplacer_1 = __webpack_require__(12); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var FunctionObfuscator = function (_AbstractNodeObfuscat) { _inherits(FunctionObfuscator, _AbstractNodeObfuscat); @@ -3055,7 +3457,7 @@ var FunctionObfuscator = function (_AbstractNodeObfuscat) { exports.FunctionObfuscator = FunctionObfuscator; /***/ }, -/* 50 */ +/* 57 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3071,10 +3473,10 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function" var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var IdentifierReplacer_1 = __webpack_require__(12); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var LabeledStatementObfuscator = function (_AbstractNodeObfuscat) { _inherits(LabeledStatementObfuscator, _AbstractNodeObfuscat); @@ -3126,7 +3528,7 @@ var LabeledStatementObfuscator = function (_AbstractNodeObfuscat) { exports.LabeledStatementObfuscator = LabeledStatementObfuscator; /***/ }, -/* 51 */ +/* 58 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3142,9 +3544,9 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var escodegen = __webpack_require__(13); -var AbstractNodeObfuscator_1 = __webpack_require__(8); -var BooleanLiteralReplacer_1 = __webpack_require__(56); +var escodegen = __webpack_require__(14); +var AbstractNodeObfuscator_1 = __webpack_require__(9); +var BooleanLiteralReplacer_1 = __webpack_require__(63); var Node_1 = __webpack_require__(2); var NumberLiteralReplacer_1 = __webpack_require__(22); var StringLiteralReplacer_1 = __webpack_require__(19); @@ -3191,7 +3593,7 @@ var LiteralObfuscator = function (_AbstractNodeObfuscat) { exports.LiteralObfuscator = LiteralObfuscator; /***/ }, -/* 52 */ +/* 59 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3205,10 +3607,10 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var escodegen = __webpack_require__(13); +var escodegen = __webpack_require__(14); var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var Node_1 = __webpack_require__(2); var StringLiteralReplacer_1 = __webpack_require__(19); @@ -3276,7 +3678,7 @@ var MemberExpressionObfuscator = function (_AbstractNodeObfuscat) { exports.MemberExpressionObfuscator = MemberExpressionObfuscator; /***/ }, -/* 53 */ +/* 60 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3291,7 +3693,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } var estraverse = __webpack_require__(4); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var Node_1 = __webpack_require__(2); var Utils_1 = __webpack_require__(0); var StringLiteralReplacer_1 = __webpack_require__(19); @@ -3335,7 +3737,7 @@ MethodDefinitionObfuscator.ignoredNames = ['constructor']; exports.MethodDefinitionObfuscator = MethodDefinitionObfuscator; /***/ }, -/* 54 */ +/* 61 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3349,10 +3751,10 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } -var escodegen = __webpack_require__(13); +var escodegen = __webpack_require__(14); var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var Node_1 = __webpack_require__(2); var Utils_1 = __webpack_require__(0); @@ -3421,7 +3823,7 @@ var ObjectExpressionObfuscator = function (_AbstractNodeObfuscat) { exports.ObjectExpressionObfuscator = ObjectExpressionObfuscator; /***/ }, -/* 55 */ +/* 62 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3437,10 +3839,10 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function" var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var AbstractNodeObfuscator_1 = __webpack_require__(8); +var AbstractNodeObfuscator_1 = __webpack_require__(9); var IdentifierReplacer_1 = __webpack_require__(12); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var VariableDeclarationObfuscator = function (_AbstractNodeObfuscat) { _inherits(VariableDeclarationObfuscator, _AbstractNodeObfuscat); @@ -3499,7 +3901,7 @@ var VariableDeclarationObfuscator = function (_AbstractNodeObfuscat) { exports.VariableDeclarationObfuscator = VariableDeclarationObfuscator; /***/ }, -/* 56 */ +/* 63 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3514,7 +3916,7 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } var JSFuck_1 = __webpack_require__(21); -var AbstractReplacer_1 = __webpack_require__(15); +var AbstractReplacer_1 = __webpack_require__(16); var BooleanLiteralReplacer = function (_AbstractReplacer_1$A) { _inherits(BooleanLiteralReplacer, _AbstractReplacer_1$A); @@ -3538,7 +3940,7 @@ var BooleanLiteralReplacer = function (_AbstractReplacer_1$A) { exports.BooleanLiteralReplacer = BooleanLiteralReplacer; /***/ }, -/* 57 */ +/* 64 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3559,12 +3961,12 @@ var __decorate = undefined && undefined.__decorate || function (decorators, targ var __metadata = undefined && undefined.__metadata || function (k, v) { if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); }; -var class_validator_1 = __webpack_require__(83); -var TSourceMapMode_1 = __webpack_require__(80); -var TStringArrayEncoding_1 = __webpack_require__(81); +var class_validator_1 = __webpack_require__(92); +var TSourceMapMode_1 = __webpack_require__(89); +var TStringArrayEncoding_1 = __webpack_require__(90); var DefaultPreset_1 = __webpack_require__(23); -var OptionsNormalizer_1 = __webpack_require__(58); -var ValidationErrorsFormatter_1 = __webpack_require__(59); +var OptionsNormalizer_1 = __webpack_require__(65); +var ValidationErrorsFormatter_1 = __webpack_require__(66); var Options = function Options(obfuscatorOptions) { _classCallCheck(this, Options); @@ -3583,6 +3985,7 @@ Options.validatorOptions = { } }; __decorate([class_validator_1.IsBoolean(), __metadata('design:type', Boolean)], Options.prototype, "compact", void 0); +__decorate([class_validator_1.IsBoolean(), __metadata('design:type', Boolean)], Options.prototype, "controlFlow", void 0); __decorate([class_validator_1.IsBoolean(), __metadata('design:type', Boolean)], Options.prototype, "debugProtection", void 0); __decorate([class_validator_1.IsBoolean(), __metadata('design:type', Boolean)], Options.prototype, "debugProtectionInterval", void 0); __decorate([class_validator_1.IsBoolean(), __metadata('design:type', Boolean)], Options.prototype, "disableConsoleOutput", void 0); @@ -3611,7 +4014,7 @@ exports.Options = Options; var _a, _b; /***/ }, -/* 58 */ +/* 65 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3778,7 +4181,7 @@ OptionsNormalizer.normalizerRules = [OptionsNormalizer.domainLockRule, OptionsNo exports.OptionsNormalizer = OptionsNormalizer; /***/ }, -/* 59 */ +/* 66 */ /***/ function(module, exports) { "use strict"; @@ -3845,7 +4248,7 @@ var ValidationErrorsFormatter = function () { exports.ValidationErrorsFormatter = ValidationErrorsFormatter; /***/ }, -/* 60 */ +/* 67 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3857,11 +4260,11 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons var estraverse = __webpack_require__(4); var NodeType_1 = __webpack_require__(6); -var FunctionDeclarationCalleeDataExtractor_1 = __webpack_require__(61); -var FunctionExpressionCalleeDataExtractor_1 = __webpack_require__(62); -var ObjectExpressionCalleeDataExtractor_1 = __webpack_require__(63); +var FunctionDeclarationCalleeDataExtractor_1 = __webpack_require__(68); +var FunctionExpressionCalleeDataExtractor_1 = __webpack_require__(69); +var ObjectExpressionCalleeDataExtractor_1 = __webpack_require__(70); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var StackTraceAnalyzer = function () { function StackTraceAnalyzer(blockScopeBody) { @@ -3938,7 +4341,7 @@ StackTraceAnalyzer.limitThreshold = 0.002; exports.StackTraceAnalyzer = StackTraceAnalyzer; /***/ }, -/* 61 */ +/* 68 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -3950,7 +4353,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons var estraverse = __webpack_require__(4); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var FunctionDeclarationCalleeDataExtractor = function () { function FunctionDeclarationCalleeDataExtractor(blockScopeBody, callee) { @@ -3997,7 +4400,7 @@ var FunctionDeclarationCalleeDataExtractor = function () { exports.FunctionDeclarationCalleeDataExtractor = FunctionDeclarationCalleeDataExtractor; /***/ }, -/* 62 */ +/* 69 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4009,7 +4412,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons var estraverse = __webpack_require__(4); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var FunctionExpressionCalleeDataExtractor = function () { function FunctionExpressionCalleeDataExtractor(blockScopeBody, callee) { @@ -4059,7 +4462,7 @@ var FunctionExpressionCalleeDataExtractor = function () { exports.FunctionExpressionCalleeDataExtractor = FunctionExpressionCalleeDataExtractor; /***/ }, -/* 63 */ +/* 70 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4071,7 +4474,7 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons var estraverse = __webpack_require__(4); var Node_1 = __webpack_require__(2); -var NodeUtils_1 = __webpack_require__(1); +var NodeUtils_1 = __webpack_require__(7); var ObjectExpressionCalleeDataExtractor = function () { function ObjectExpressionCalleeDataExtractor(blockScopeBody, callee) { @@ -4191,7 +4594,7 @@ var ObjectExpressionCalleeDataExtractor = function () { exports.ObjectExpressionCalleeDataExtractor = ObjectExpressionCalleeDataExtractor; /***/ }, -/* 64 */ +/* 71 */ /***/ function(module, exports) { "use strict"; @@ -4203,7 +4606,7 @@ function AtobTemplate() { exports.AtobTemplate = AtobTemplate; /***/ }, -/* 65 */ +/* 72 */ /***/ function(module, exports) { "use strict"; @@ -4215,7 +4618,7 @@ function Rc4Template() { exports.Rc4Template = Rc4Template; /***/ }, -/* 66 */ +/* 73 */ /***/ function(module, exports) { "use strict"; @@ -4227,7 +4630,7 @@ function SingleNodeCallControllerTemplate() { exports.SingleNodeCallControllerTemplate = SingleNodeCallControllerTemplate; /***/ }, -/* 67 */ +/* 74 */ /***/ function(module, exports) { "use strict"; @@ -4239,7 +4642,31 @@ function ConsoleOutputDisableExpressionTemplate() { exports.ConsoleOutputDisableExpressionTemplate = ConsoleOutputDisableExpressionTemplate; /***/ }, -/* 68 */ +/* 75 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function BinaryExpressionSumFunctionTemplate() { + return "\n function {functionName} (x, y) {\n return x + y;\n }\n "; +} +exports.BinaryExpressionSumFunctionTemplate = BinaryExpressionSumFunctionTemplate; + +/***/ }, +/* 76 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function ControlFlowStorageTemplate() { + return "\n var {controlFlowStorageName} = {controlFlowStorage};\n "; +} +exports.ControlFlowStorageTemplate = ControlFlowStorageTemplate; + +/***/ }, +/* 77 */ /***/ function(module, exports) { "use strict"; @@ -4251,7 +4678,7 @@ function DebugProtectionFunctionCallTemplate() { exports.DebugProtectionFunctionCallTemplate = DebugProtectionFunctionCallTemplate; /***/ }, -/* 69 */ +/* 78 */ /***/ function(module, exports) { "use strict"; @@ -4263,7 +4690,7 @@ function DebugProtectionFunctionIntervalTemplate() { exports.DebugProtectionFunctionIntervalTemplate = DebugProtectionFunctionIntervalTemplate; /***/ }, -/* 70 */ +/* 79 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4276,7 +4703,7 @@ function DebugProtectionFunctionTemplate() { exports.DebugProtectionFunctionTemplate = DebugProtectionFunctionTemplate; /***/ }, -/* 71 */ +/* 80 */ /***/ function(module, exports) { "use strict"; @@ -4288,7 +4715,7 @@ function DomainLockNodeTemplate() { exports.DomainLockNodeTemplate = DomainLockNodeTemplate; /***/ }, -/* 72 */ +/* 81 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4301,7 +4728,7 @@ function SelfDefendingTemplate() { exports.SelfDefendingTemplate = SelfDefendingTemplate; /***/ }, -/* 73 */ +/* 82 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4314,7 +4741,7 @@ function SelfDefendingTemplate() { exports.SelfDefendingTemplate = SelfDefendingTemplate; /***/ }, -/* 74 */ +/* 83 */ /***/ function(module, exports) { "use strict"; @@ -4326,7 +4753,7 @@ function StringArrayBase64DecodeNodeTemplate() { exports.StringArrayBase64DecodeNodeTemplate = StringArrayBase64DecodeNodeTemplate; /***/ }, -/* 75 */ +/* 84 */ /***/ function(module, exports) { "use strict"; @@ -4338,7 +4765,7 @@ function StringArrayCallsWrapperTemplate() { exports.StringArrayCallsWrapperTemplate = StringArrayCallsWrapperTemplate; /***/ }, -/* 76 */ +/* 85 */ /***/ function(module, exports) { "use strict"; @@ -4350,7 +4777,7 @@ function StringArrayRc4DecodeNodeTemplate() { exports.StringArrayRc4DecodeNodeTemplate = StringArrayRc4DecodeNodeTemplate; /***/ }, -/* 77 */ +/* 86 */ /***/ function(module, exports) { "use strict"; @@ -4362,7 +4789,7 @@ function StringArrayTemplate() { exports.StringArrayTemplate = StringArrayTemplate; /***/ }, -/* 78 */ +/* 87 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4375,7 +4802,7 @@ function SelfDefendingTemplate() { exports.SelfDefendingTemplate = SelfDefendingTemplate; /***/ }, -/* 79 */ +/* 88 */ /***/ function(module, exports) { "use strict"; @@ -4387,53 +4814,52 @@ function StringArrayRotateFunctionTemplate() { exports.StringArrayRotateFunctionTemplate = StringArrayRotateFunctionTemplate; /***/ }, -/* 80 */ +/* 89 */ /***/ function(module, exports) { "use strict"; "use strict"; /***/ }, -/* 81 */ +/* 90 */ /***/ function(module, exports) { "use strict"; "use strict"; /***/ }, -/* 82 */ +/* 91 */ /***/ function(module, exports) { module.exports = require("chance"); /***/ }, -/* 83 */ +/* 92 */ /***/ function(module, exports) { module.exports = require("class-validator"); /***/ }, -/* 84 */ +/* 93 */ /***/ function(module, exports) { module.exports = require("commander"); /***/ }, -/* 85 */ +/* 94 */ /***/ function(module, exports) { module.exports = require("fs"); /***/ }, -/* 86 */ +/* 95 */ /***/ function(module, exports) { module.exports = require("mkdirp"); /***/ }, -/* 87 */, -/* 88 */, -/* 89 */ +/* 96 */, +/* 97 */ /***/ function(module, exports, __webpack_require__) { "use strict"; @@ -4445,6 +4871,333 @@ if (!global._babelPolyfill) { } module.exports = JavaScriptObfuscator_1.JavaScriptObfuscator; +/***/ }, +/* 98 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var ControlFlowStorageCallTemplate_1 = __webpack_require__(99); +var AbstractCustomNode_1 = __webpack_require__(5); +var NodeAppender_1 = __webpack_require__(3); + +var ControlFlowStorageCallNode = function (_AbstractCustomNode_) { + _inherits(ControlFlowStorageCallNode, _AbstractCustomNode_); + + function ControlFlowStorageCallNode(controlFlowStorageName, controlFlowStorageKey, leftValue, rightValue, options) { + _classCallCheck(this, ControlFlowStorageCallNode); + + var _this = _possibleConstructorReturn(this, (ControlFlowStorageCallNode.__proto__ || Object.getPrototypeOf(ControlFlowStorageCallNode)).call(this, options)); + + _this.appendState = AppendState_1.AppendState.AfterObfuscation; + _this.controlFlowStorageName = controlFlowStorageName; + _this.controlFlowStorageKey = controlFlowStorageKey; + _this.leftValue = leftValue; + _this.rightValue = rightValue; + return _this; + } + + _createClass(ControlFlowStorageCallNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) { + NodeAppender_1.NodeAppender.prependNode(blockScopeNode, this.getNode()); + } + }, { + key: 'getCode', + value: function getCode() { + return ControlFlowStorageCallTemplate_1.ControlFlowStorageCallTemplate().formatUnicorn({ + controlFlowStorageKey: this.controlFlowStorageKey, + controlFlowStorageName: this.controlFlowStorageName, + leftValue: this.leftValue, + rightValue: this.rightValue + }); + } + }]); + + return ControlFlowStorageCallNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.ControlFlowStorageCallNode = ControlFlowStorageCallNode; + +/***/ }, +/* 99 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function ControlFlowStorageCallTemplate() { + return '{controlFlowStorageName}.{controlFlowStorageKey}({leftValue}, {rightValue})'; +} +exports.ControlFlowStorageCallTemplate = ControlFlowStorageCallTemplate; + +/***/ }, +/* 100 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var BinaryExpressionDivideFunctionTemplate_1 = __webpack_require__(104); +var AbstractCustomNode_1 = __webpack_require__(5); +var JavaScriptObfuscator_1 = __webpack_require__(10); +var Utils_1 = __webpack_require__(0); + +var BinaryExpressionDivideFunctionNode = function (_AbstractCustomNode_) { + _inherits(BinaryExpressionDivideFunctionNode, _AbstractCustomNode_); + + function BinaryExpressionDivideFunctionNode() { + _classCallCheck(this, BinaryExpressionDivideFunctionNode); + + var _this = _possibleConstructorReturn(this, (BinaryExpressionDivideFunctionNode.__proto__ || Object.getPrototypeOf(BinaryExpressionDivideFunctionNode)).apply(this, arguments)); + + _this.appendState = AppendState_1.AppendState.BeforeObfuscation; + return _this; + } + + _createClass(BinaryExpressionDivideFunctionNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) {} + }, { + key: 'getCode', + value: function getCode() { + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(BinaryExpressionDivideFunctionTemplate_1.BinaryExpressionDivideFunctionTemplate().formatUnicorn({ + functionName: Utils_1.Utils.getRandomVariableName() + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); + } + }]); + + return BinaryExpressionDivideFunctionNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.BinaryExpressionDivideFunctionNode = BinaryExpressionDivideFunctionNode; + +/***/ }, +/* 101 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var BinaryExpressionExponentitionFunctionTemplate_1 = __webpack_require__(105); +var AbstractCustomNode_1 = __webpack_require__(5); +var JavaScriptObfuscator_1 = __webpack_require__(10); +var Utils_1 = __webpack_require__(0); + +var BinaryExpressionExponentiationFunctionNode = function (_AbstractCustomNode_) { + _inherits(BinaryExpressionExponentiationFunctionNode, _AbstractCustomNode_); + + function BinaryExpressionExponentiationFunctionNode() { + _classCallCheck(this, BinaryExpressionExponentiationFunctionNode); + + var _this = _possibleConstructorReturn(this, (BinaryExpressionExponentiationFunctionNode.__proto__ || Object.getPrototypeOf(BinaryExpressionExponentiationFunctionNode)).apply(this, arguments)); + + _this.appendState = AppendState_1.AppendState.BeforeObfuscation; + return _this; + } + + _createClass(BinaryExpressionExponentiationFunctionNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) {} + }, { + key: 'getCode', + value: function getCode() { + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(BinaryExpressionExponentitionFunctionTemplate_1.BinaryExpressionExponentiationFunctionTemplate().formatUnicorn({ + functionName: Utils_1.Utils.getRandomVariableName() + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); + } + }]); + + return BinaryExpressionExponentiationFunctionNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.BinaryExpressionExponentiationFunctionNode = BinaryExpressionExponentiationFunctionNode; + +/***/ }, +/* 102 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var BinaryExpressionMultiplyFunctionTemplate_1 = __webpack_require__(106); +var AbstractCustomNode_1 = __webpack_require__(5); +var JavaScriptObfuscator_1 = __webpack_require__(10); +var Utils_1 = __webpack_require__(0); + +var BinaryExpressionMultiplyFunctionNode = function (_AbstractCustomNode_) { + _inherits(BinaryExpressionMultiplyFunctionNode, _AbstractCustomNode_); + + function BinaryExpressionMultiplyFunctionNode() { + _classCallCheck(this, BinaryExpressionMultiplyFunctionNode); + + var _this = _possibleConstructorReturn(this, (BinaryExpressionMultiplyFunctionNode.__proto__ || Object.getPrototypeOf(BinaryExpressionMultiplyFunctionNode)).apply(this, arguments)); + + _this.appendState = AppendState_1.AppendState.BeforeObfuscation; + return _this; + } + + _createClass(BinaryExpressionMultiplyFunctionNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) {} + }, { + key: 'getCode', + value: function getCode() { + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(BinaryExpressionMultiplyFunctionTemplate_1.BinaryExpressionMultiplyFunctionTemplate().formatUnicorn({ + functionName: Utils_1.Utils.getRandomVariableName() + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); + } + }]); + + return BinaryExpressionMultiplyFunctionNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.BinaryExpressionMultiplyFunctionNode = BinaryExpressionMultiplyFunctionNode; + +/***/ }, +/* 103 */ +/***/ function(module, exports, __webpack_require__) { + +"use strict"; +"use strict"; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +__webpack_require__(8); +var AppendState_1 = __webpack_require__(1); +var NoCustomNodesPreset_1 = __webpack_require__(13); +var BinaryExpressionSubtractFunctionTemplate_1 = __webpack_require__(107); +var AbstractCustomNode_1 = __webpack_require__(5); +var JavaScriptObfuscator_1 = __webpack_require__(10); +var Utils_1 = __webpack_require__(0); + +var BinaryExpressionSubtractFunctionNode = function (_AbstractCustomNode_) { + _inherits(BinaryExpressionSubtractFunctionNode, _AbstractCustomNode_); + + function BinaryExpressionSubtractFunctionNode() { + _classCallCheck(this, BinaryExpressionSubtractFunctionNode); + + var _this = _possibleConstructorReturn(this, (BinaryExpressionSubtractFunctionNode.__proto__ || Object.getPrototypeOf(BinaryExpressionSubtractFunctionNode)).apply(this, arguments)); + + _this.appendState = AppendState_1.AppendState.BeforeObfuscation; + return _this; + } + + _createClass(BinaryExpressionSubtractFunctionNode, [{ + key: 'appendNode', + value: function appendNode(blockScopeNode) {} + }, { + key: 'getCode', + value: function getCode() { + return JavaScriptObfuscator_1.JavaScriptObfuscator.obfuscate(BinaryExpressionSubtractFunctionTemplate_1.BinaryExpressionSubtractFunctionTemplate().formatUnicorn({ + functionName: Utils_1.Utils.getRandomVariableName() + }), NoCustomNodesPreset_1.NO_CUSTOM_NODES_PRESET).getObfuscatedCode(); + } + }]); + + return BinaryExpressionSubtractFunctionNode; +}(AbstractCustomNode_1.AbstractCustomNode); + +exports.BinaryExpressionSubtractFunctionNode = BinaryExpressionSubtractFunctionNode; + +/***/ }, +/* 104 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function BinaryExpressionDivideFunctionTemplate() { + return "\n function {functionName} (x, y) {\n return x / y;\n }\n "; +} +exports.BinaryExpressionDivideFunctionTemplate = BinaryExpressionDivideFunctionTemplate; + +/***/ }, +/* 105 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function BinaryExpressionExponentiationFunctionTemplate() { + return "\n function {functionName} (x, y) {\n return Math.pow(x, y);\n }\n "; +} +exports.BinaryExpressionExponentiationFunctionTemplate = BinaryExpressionExponentiationFunctionTemplate; + +/***/ }, +/* 106 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function BinaryExpressionMultiplyFunctionTemplate() { + return "\n function {functionName} (x, y) {\n return x * y;\n }\n "; +} +exports.BinaryExpressionMultiplyFunctionTemplate = BinaryExpressionMultiplyFunctionTemplate; + +/***/ }, +/* 107 */ +/***/ function(module, exports) { + +"use strict"; +"use strict"; + +function BinaryExpressionSubtractFunctionTemplate() { + return "\n function {functionName} (x, y) {\n return x - y;\n }\n "; +} +exports.BinaryExpressionSubtractFunctionTemplate = BinaryExpressionSubtractFunctionTemplate; + /***/ } /******/ ]); //# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/src/ControlFlowStorage.ts b/src/ControlFlowStorage.ts new file mode 100644 index 00000000..d2253ec7 --- /dev/null +++ b/src/ControlFlowStorage.ts @@ -0,0 +1,50 @@ +import { ICustomNode } from './interfaces/custom-nodes/ICustomNode'; + +export class ControlFlowStorage { + /** + * @type {Map } + */ + private storage: Map = new Map (); + + /** + * @param key + * @param value + */ + public addToStorage (key: string, value: ICustomNode): void { + this.storage.set(key, value); + } + + /** + * @returns {Map } + */ + public getStorage (): Map { + return this.storage; + } + + /** + * @param key + * @returns {Function} + */ + public getStorageItem(key: string): ICustomNode { + const value: ICustomNode | undefined = this.storage.get(key); + + if (!value) { + throw new Error(`No value found in ControlFlowStorage with key \`${key}\``); + } + + return value; + } + + /** + * @returns {string} + */ + public toString (): string { + return `{ + ${Array.from(this.storage).reduce((string: string, [key, value]: [string, ICustomNode]) => { + string += `${key}: ${value.getCode()},`; + + return string; + }, '')} + }`; + } +} diff --git a/src/Obfuscator.ts b/src/Obfuscator.ts index a031a92e..3f2b73cd 100644 --- a/src/Obfuscator.ts +++ b/src/Obfuscator.ts @@ -1,6 +1,7 @@ import * as estraverse from 'estraverse'; import * as ESTree from 'estree'; +import { TNodeControlFlowChanger } from './types/TNodeControlFlowChanger'; import { TNodeGroup } from './types/TNodeGroup'; import { TNodeObfuscator } from './types/TNodeObfuscator'; @@ -29,8 +30,17 @@ import { SelfDefendingNodesGroup } from './node-groups/SelfDefendingNodesGroup'; import { StackTraceAnalyzer } from './stack-trace-analyzer/StackTraceAnalyzer'; import { StringArrayNodesGroup } from './node-groups/StringArrayNodesGroup'; import { VariableDeclarationObfuscator } from './node-obfuscators/VariableDeclarationObfuscator'; +import { FunctionControlFlowChanger } from './node-control-flow-changers/FunctionControlFlowChanger'; export class Obfuscator implements IObfuscator { + /** + * @type {Map} + */ + private static nodeControlFlowChangers: Map = new Map ([ + [NodeType.FunctionDeclaration, [FunctionControlFlowChanger]], + [NodeType.FunctionExpression, [FunctionControlFlowChanger]] + ]); + /** * @type {TNodeGroup[]} */ @@ -98,6 +108,10 @@ export class Obfuscator implements IObfuscator { this.obfuscate(node); this.afterObfuscation(node); + if (this.options.controlFlow) { + this.changeControlFlow(node); + } + return node; } @@ -123,6 +137,17 @@ export class Obfuscator implements IObfuscator { }); }; + /** + * @param node + */ + private changeControlFlow (node: ESTree.Node): void { + estraverse.traverse(node, { + leave: (node: ESTree.Node, parentNode: ESTree.Node): void => { + this.initializeNodeControlFlowChangers(node, parentNode); + } + }); + } + /** * @param stackTraceData */ @@ -144,6 +169,21 @@ export class Obfuscator implements IObfuscator { this.customNodes = new Map (customNodes); } + /** + * @param node + * @param parentNode + */ + private initializeNodeControlFlowChangers (node: ESTree.Node, parentNode: ESTree.Node): void { + let nodeControlFlowChangers: TNodeControlFlowChanger[] | undefined = Obfuscator.nodeControlFlowChangers.get(node.type); + + if (!nodeControlFlowChangers) { + return; + } + + nodeControlFlowChangers.forEach((controlFlowChanger: TNodeControlFlowChanger) => { + new controlFlowChanger(this.customNodes, this.options).changeControlFlow(node, parentNode); + }); + } /** * @param node diff --git a/src/custom-nodes/AbstractCustomNode.ts b/src/custom-nodes/AbstractCustomNode.ts index 00aa6a3c..336c6b9e 100644 --- a/src/custom-nodes/AbstractCustomNode.ts +++ b/src/custom-nodes/AbstractCustomNode.ts @@ -5,6 +5,7 @@ import { IOptions } from '../interfaces/IOptions'; import { TStatement } from '../types/TStatement'; import { AppendState } from '../enums/AppendState'; +import { NodeUtils } from '../node/NodeUtils'; export abstract class AbstractCustomNode implements ICustomNode { /** @@ -36,6 +37,11 @@ export abstract class AbstractCustomNode implements ICustomNode { return this.appendState; } + /** + * @returns {string} + */ + public abstract getCode (): string; + /** * @returns {TStatement[]} */ @@ -53,5 +59,7 @@ export abstract class AbstractCustomNode implements ICustomNode { /** * @returns {TStatement[]} */ - protected abstract getNodeStructure (): TStatement[]; + protected getNodeStructure (): TStatement[] { + return NodeUtils.convertCodeToStructure(this.getCode()); + } } diff --git a/src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.ts b/src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.ts index 89dadd35..3691bbb3 100644 --- a/src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.ts +++ b/src/custom-nodes/console-output-nodes/ConsoleOutputDisableExpressionNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; import { IStackTraceData } from '../../interfaces/stack-trace-analyzer/IStackTraceData'; @@ -12,7 +11,6 @@ import { ConsoleOutputDisableExpressionTemplate } from '../../templates/custom-n import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; import { Utils } from '../../Utils'; export class ConsoleOutputDisableExpressionNode extends AbstractCustomNode { @@ -68,27 +66,12 @@ export class ConsoleOutputDisableExpressionNode extends AbstractCustomNode { } /** - * JSCrush version of following code - * - * (function () { - * var _console = []["filter"]["constructor"]("return this")().console; - * var _function = function () {}; - * - * _console.log = _function; - * _console.info = _function; - * _console.warn = _function; - * _console.error = _function; - * _console - * })(); - * - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { - return NodeUtils.convertCodeToStructure( - ConsoleOutputDisableExpressionTemplate().formatUnicorn({ - consoleLogDisableFunctionName: Utils.getRandomVariableName(), - singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }) - ); + public getCode (): string { + return ConsoleOutputDisableExpressionTemplate().formatUnicorn({ + consoleLogDisableFunctionName: Utils.getRandomVariableName(), + singleNodeCallControllerFunctionName: this.callsControllerFunctionName + }); } } diff --git a/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionNode.ts b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionNode.ts new file mode 100644 index 00000000..1ed7e7d5 --- /dev/null +++ b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionNode.ts @@ -0,0 +1,39 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../../types/TNodeWithBlockStatement'; + +import { AppendState } from '../../../enums/AppendState'; + +import { NO_CUSTOM_NODES_PRESET } from '../../../preset-options/NoCustomNodesPreset'; + +import { BinaryExpressionDivideFunctionTemplate } from '../../../templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionTemplate'; + +import { AbstractCustomNode } from '../../AbstractCustomNode'; +import { JavaScriptObfuscator } from '../../../JavaScriptObfuscator'; +import { Utils } from '../../../Utils'; + +export class BinaryExpressionDivideFunctionNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.BeforeObfuscation; + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + + } + + /** + * @returns {string} + */ + public getCode (): string { + return JavaScriptObfuscator.obfuscate( + BinaryExpressionDivideFunctionTemplate().formatUnicorn({ + functionName: Utils.getRandomVariableName() + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); + } +} diff --git a/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentiationFunctionNode.ts b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentiationFunctionNode.ts new file mode 100644 index 00000000..1bb6fb8d --- /dev/null +++ b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentiationFunctionNode.ts @@ -0,0 +1,39 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../../types/TNodeWithBlockStatement'; + +import { AppendState } from '../../../enums/AppendState'; + +import { NO_CUSTOM_NODES_PRESET } from '../../../preset-options/NoCustomNodesPreset'; + +import { BinaryExpressionExponentiationFunctionTemplate } from '../../../templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentitionFunctionTemplate'; + +import { AbstractCustomNode } from '../../AbstractCustomNode'; +import { JavaScriptObfuscator } from '../../../JavaScriptObfuscator'; +import { Utils } from '../../../Utils'; + +export class BinaryExpressionExponentiationFunctionNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.BeforeObfuscation; + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + + } + + /** + * @returns {string} + */ + public getCode (): string { + return JavaScriptObfuscator.obfuscate( + BinaryExpressionExponentiationFunctionTemplate().formatUnicorn({ + functionName: Utils.getRandomVariableName() + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); + } +} diff --git a/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionNode.ts b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionNode.ts new file mode 100644 index 00000000..98078d7a --- /dev/null +++ b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionNode.ts @@ -0,0 +1,39 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../../types/TNodeWithBlockStatement'; + +import { AppendState } from '../../../enums/AppendState'; + +import { NO_CUSTOM_NODES_PRESET } from '../../../preset-options/NoCustomNodesPreset'; + +import { BinaryExpressionMultiplyFunctionTemplate } from '../../../templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionTemplate'; + +import { AbstractCustomNode } from '../../AbstractCustomNode'; +import { JavaScriptObfuscator } from '../../../JavaScriptObfuscator'; +import { Utils } from '../../../Utils'; + +export class BinaryExpressionMultiplyFunctionNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.BeforeObfuscation; + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + + } + + /** + * @returns {string} + */ + public getCode (): string { + return JavaScriptObfuscator.obfuscate( + BinaryExpressionMultiplyFunctionTemplate().formatUnicorn({ + functionName: Utils.getRandomVariableName() + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); + } +} diff --git a/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionNode.ts b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionNode.ts new file mode 100644 index 00000000..e36ba136 --- /dev/null +++ b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionNode.ts @@ -0,0 +1,39 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../../types/TNodeWithBlockStatement'; + +import { AppendState } from '../../../enums/AppendState'; + +import { NO_CUSTOM_NODES_PRESET } from '../../../preset-options/NoCustomNodesPreset'; + +import { BinaryExpressionSubtractFunctionTemplate } from '../../../templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionTemplate'; + +import { AbstractCustomNode } from '../../AbstractCustomNode'; +import { JavaScriptObfuscator } from '../../../JavaScriptObfuscator'; +import { Utils } from '../../../Utils'; + +export class BinaryExpressionSubtractFunctionNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.BeforeObfuscation; + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + + } + + /** + * @returns {string} + */ + public getCode (): string { + return JavaScriptObfuscator.obfuscate( + BinaryExpressionSubtractFunctionTemplate().formatUnicorn({ + functionName: Utils.getRandomVariableName() + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); + } +} diff --git a/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionNode.ts b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionNode.ts new file mode 100644 index 00000000..f9fd8ba5 --- /dev/null +++ b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionNode.ts @@ -0,0 +1,39 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../../types/TNodeWithBlockStatement'; + +import { AppendState } from '../../../enums/AppendState'; + +import { NO_CUSTOM_NODES_PRESET } from '../../../preset-options/NoCustomNodesPreset'; + +import { BinaryExpressionSumFunctionTemplate } from '../../../templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionTemplate'; + +import { AbstractCustomNode } from '../../AbstractCustomNode'; +import { JavaScriptObfuscator } from '../../../JavaScriptObfuscator'; +import { Utils } from '../../../Utils'; + +export class BinaryExpressionSumFunctionNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.BeforeObfuscation; + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + + } + + /** + * @returns {string} + */ + public getCode (): string { + return JavaScriptObfuscator.obfuscate( + BinaryExpressionSumFunctionTemplate().formatUnicorn({ + functionName: Utils.getRandomVariableName() + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); + } +} diff --git a/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallNode.ts b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallNode.ts new file mode 100644 index 00000000..af49d7ce --- /dev/null +++ b/src/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallNode.ts @@ -0,0 +1,80 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../../types/TNodeWithBlockStatement'; + +import { IOptions } from '../../../interfaces/IOptions'; + +import { AppendState } from '../../../enums/AppendState'; + +import { ControlFlowStorageCallTemplate } from '../../../templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallTemplate'; + +import { AbstractCustomNode } from '../../AbstractCustomNode'; +import { NodeAppender } from '../../../node/NodeAppender'; + +export class ControlFlowStorageCallNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.AfterObfuscation; + + /** + * @type {string} + */ + private controlFlowStorageKey: string; + + /** + * @type {string} + */ + private controlFlowStorageName: string; + + /** + * @type {string} + */ + private leftValue: string; + + /** + * @type {string} + */ + private rightValue: string; + + /** + * @param controlFlowStorageName + * @param controlFlowStorageKey + * @param leftValue + * @param rightValue + * @param options + */ + constructor ( + controlFlowStorageName: string, + controlFlowStorageKey: string, + leftValue: string, + rightValue: string, + options: IOptions + ) { + super(options); + + this.controlFlowStorageName = controlFlowStorageName; + this.controlFlowStorageKey = controlFlowStorageKey; + this.leftValue = leftValue; + this.rightValue = rightValue; + } + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + NodeAppender.prependNode(blockScopeNode, this.getNode()); + } + + /** + * @returns {string} + */ + public getCode (): string { + return ControlFlowStorageCallTemplate().formatUnicorn({ + controlFlowStorageKey: this.controlFlowStorageKey, + controlFlowStorageName: this.controlFlowStorageName, + leftValue: this.leftValue, + rightValue: this.rightValue + }); + } +} diff --git a/src/custom-nodes/control-flow-storage-nodes/ControlFlowStorageNode.ts b/src/custom-nodes/control-flow-storage-nodes/ControlFlowStorageNode.ts new file mode 100644 index 00000000..16993bbf --- /dev/null +++ b/src/custom-nodes/control-flow-storage-nodes/ControlFlowStorageNode.ts @@ -0,0 +1,87 @@ +import 'format-unicorn'; + +import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; + +import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode'; +import { IOptions } from '../../interfaces/IOptions'; + +import { AppendState } from '../../enums/AppendState'; + +import { ControlFlowStorage } from '../../ControlFlowStorage'; + +import { ControlFlowStorageTemplate } from '../../templates/custom-nodes/control-flow-storage-nodes/ControlFlowStorageTemplate'; + +import { AbstractCustomNode } from '../AbstractCustomNode'; +import { NodeAppender } from '../../node/NodeAppender'; + +export class ControlFlowStorageNode extends AbstractCustomNode { + /** + * @type {AppendState} + */ + protected appendState: AppendState = AppendState.AfterObfuscation; + + /** + * @type {ControlFlowStorage} + */ + private controlFlowStorage: ControlFlowStorage; + + /** + * @type {string} + */ + private controlFlowStorageName: string; + + /** + * @param controlFlowStorage + * @param controlFlowStorageName + * @param options + */ + constructor ( + controlFlowStorage: ControlFlowStorage, + controlFlowStorageName: string, + options: IOptions + ) { + super(options); + + this.controlFlowStorage = controlFlowStorage; + this.controlFlowStorageName = controlFlowStorageName; + } + + /** + * @param blockScopeNode + */ + public appendNode (blockScopeNode: TNodeWithBlockStatement): void { + NodeAppender.prependNode(blockScopeNode, this.getNode()); + } + + /** + * @returns {string} + */ + public getCode (): string { + return ControlFlowStorageTemplate().formatUnicorn({ + controlFlowStorage: this.controlFlowStorage.toString(), + controlFlowStorageName: this.controlFlowStorageName + }); + } + + /** + * @returns {string} + */ + public getNodeIdentifier (): string { + return this.controlFlowStorageName; + } + + /** + * @returns {StringArray} + */ + public getNodeData (): ControlFlowStorage { + return this.controlFlowStorage; + } + + /** + * @param key + * @param value + */ + public updateNodeData (key: string, value: ICustomNode): void { + this.controlFlowStorage.addToStorage(key, value); + } +} diff --git a/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode.ts b/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode.ts index 99205b51..b563033a 100644 --- a/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode.ts +++ b/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionCallNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; @@ -11,7 +10,6 @@ import { DebugProtectionFunctionCallTemplate } from '../../templates/custom-node import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; export class DebugProtectionFunctionCallNode extends AbstractCustomNode { /** @@ -42,13 +40,11 @@ export class DebugProtectionFunctionCallNode extends AbstractCustomNode { } /** - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { - return NodeUtils.convertCodeToStructure( - DebugProtectionFunctionCallTemplate().formatUnicorn({ - debugProtectionFunctionName: this.debugProtectionFunctionName - }) - ); + public getCode (): string { + return DebugProtectionFunctionCallTemplate().formatUnicorn({ + debugProtectionFunctionName: this.debugProtectionFunctionName + }); } } diff --git a/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode.ts b/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode.ts index f0d10f08..237e8196 100644 --- a/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode.ts +++ b/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionIntervalNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; @@ -11,7 +10,6 @@ import { DebugProtectionFunctionIntervalTemplate } from '../../templates/custom- import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; export class DebugProtectionFunctionIntervalNode extends AbstractCustomNode { /** @@ -42,13 +40,11 @@ export class DebugProtectionFunctionIntervalNode extends AbstractCustomNode { } /** - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { - return NodeUtils.convertCodeToStructure( - DebugProtectionFunctionIntervalTemplate().formatUnicorn({ - debugProtectionFunctionName: this.debugProtectionFunctionName - }) - ); + public getCode (): string { + return DebugProtectionFunctionIntervalTemplate().formatUnicorn({ + debugProtectionFunctionName: this.debugProtectionFunctionName + }); } } diff --git a/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode.ts b/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode.ts index e5444285..19ffe0b1 100644 --- a/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode.ts +++ b/src/custom-nodes/debug-protection-nodes/DebugProtectionFunctionNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; @@ -11,7 +10,6 @@ import { DebugProtectionFunctionTemplate } from '../../templates/custom-nodes/de import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; import { Utils } from '../../Utils'; export class DebugProtectionFunctionNode extends AbstractCustomNode { @@ -51,20 +49,16 @@ export class DebugProtectionFunctionNode extends AbstractCustomNode { /** * @returns {string} */ - public getNodeIdentifier (): string { - return this.debugProtectionFunctionName; + public getCode (): string { + return DebugProtectionFunctionTemplate().formatUnicorn({ + debugProtectionFunctionName: this.debugProtectionFunctionName + }); } /** - * Found this trick in JScrambler - * - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { - return NodeUtils.convertCodeToStructure( - DebugProtectionFunctionTemplate().formatUnicorn({ - debugProtectionFunctionName: this.debugProtectionFunctionName - }) - ); + public getNodeIdentifier (): string { + return this.debugProtectionFunctionName; } } diff --git a/src/custom-nodes/domain-lock-nodes/DomainLockNode.ts b/src/custom-nodes/domain-lock-nodes/DomainLockNode.ts index a25be4f4..d308bad3 100644 --- a/src/custom-nodes/domain-lock-nodes/DomainLockNode.ts +++ b/src/custom-nodes/domain-lock-nodes/DomainLockNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; import { IStackTraceData } from '../../interfaces/stack-trace-analyzer/IStackTraceData'; @@ -12,7 +11,6 @@ import { DomainLockNodeTemplate } from '../../templates/custom-nodes/domain-lock import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; import { Utils } from '../../Utils'; export class DomainLockNode extends AbstractCustomNode { @@ -68,19 +66,17 @@ export class DomainLockNode extends AbstractCustomNode { } /** - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { + public getCode (): string { let domainsString: string = this.options.domainLock.join(';'), [hiddenDomainsString, diff]: string[] = Utils.hideString(domainsString, domainsString.length * 3); - return NodeUtils.convertCodeToStructure( - DomainLockNodeTemplate().formatUnicorn({ - domainLockFunctionName: Utils.getRandomVariableName(), - diff: diff, - domains: hiddenDomainsString, - singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }) - ); + return DomainLockNodeTemplate().formatUnicorn({ + domainLockFunctionName: Utils.getRandomVariableName(), + diff: diff, + domains: hiddenDomainsString, + singleNodeCallControllerFunctionName: this.callsControllerFunctionName + }); } } diff --git a/src/custom-nodes/node-calls-controller-nodes/NodeCallsControllerFunctionNode.ts b/src/custom-nodes/node-calls-controller-nodes/NodeCallsControllerFunctionNode.ts index 338d4122..664175a4 100644 --- a/src/custom-nodes/node-calls-controller-nodes/NodeCallsControllerFunctionNode.ts +++ b/src/custom-nodes/node-calls-controller-nodes/NodeCallsControllerFunctionNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; import { IStackTraceData } from '../../interfaces/stack-trace-analyzer/IStackTraceData'; @@ -15,7 +14,6 @@ import { NO_CUSTOM_NODES_PRESET } from '../../preset-options/NoCustomNodesPreset import { AbstractCustomNode } from '../AbstractCustomNode'; import { JavaScriptObfuscator } from '../../JavaScriptObfuscator'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; export class NodeCallsControllerFunctionNode extends AbstractCustomNode { /** @@ -74,21 +72,20 @@ export class NodeCallsControllerFunctionNode extends AbstractCustomNode { } /** - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { + public getCode (): string { if (this.appendState === AppendState.AfterObfuscation) { - return NodeUtils.convertCodeToStructure( - JavaScriptObfuscator.obfuscate(SingleNodeCallControllerTemplate().formatUnicorn({ + return JavaScriptObfuscator.obfuscate( + SingleNodeCallControllerTemplate().formatUnicorn({ singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }), NO_CUSTOM_NODES_PRESET).getObfuscatedCode() - ); + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); } - return NodeUtils.convertCodeToStructure( - SingleNodeCallControllerTemplate().formatUnicorn({ - singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }) - ); + return SingleNodeCallControllerTemplate().formatUnicorn({ + singleNodeCallControllerFunctionName: this.callsControllerFunctionName + }); } } diff --git a/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts b/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts index 0562a13e..5968d3eb 100644 --- a/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts +++ b/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts @@ -1,5 +1,4 @@ import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; import { IStackTraceData } from '../../interfaces/stack-trace-analyzer/IStackTraceData'; @@ -13,7 +12,6 @@ import { SelfDefendingTemplate } from '../../templates/custom-nodes/self-defendi import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; import { JavaScriptObfuscator } from '../../JavaScriptObfuscator'; -import { NodeUtils } from '../../node/NodeUtils'; import { Utils } from '../../Utils'; export class SelfDefendingUnicodeNode extends AbstractCustomNode { @@ -69,17 +67,15 @@ export class SelfDefendingUnicodeNode extends AbstractCustomNode { } /** - * @returns {TStatement[]} + * @returns {string} */ - protected getNodeStructure (): TStatement[] { - return NodeUtils.convertCodeToStructure( - JavaScriptObfuscator.obfuscate( - SelfDefendingTemplate().formatUnicorn({ - selfDefendingFunctionName: Utils.getRandomVariableName(), - singleNodeCallControllerFunctionName: this.callsControllerFunctionName - }), - NO_CUSTOM_NODES_PRESET - ).getObfuscatedCode() - ); + public getCode (): string { + return JavaScriptObfuscator.obfuscate( + SelfDefendingTemplate().formatUnicorn({ + selfDefendingFunctionName: Utils.getRandomVariableName(), + singleNodeCallControllerFunctionName: this.callsControllerFunctionName + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); } } diff --git a/src/custom-nodes/string-array-nodes/StringArrayCallsWrapper.ts b/src/custom-nodes/string-array-nodes/StringArrayCallsWrapper.ts index 849dfab5..2e4c42c1 100644 --- a/src/custom-nodes/string-array-nodes/StringArrayCallsWrapper.ts +++ b/src/custom-nodes/string-array-nodes/StringArrayCallsWrapper.ts @@ -20,7 +20,6 @@ import { StringArrayRc4DecodeNodeTemplate } from '../../templates/custom-nodes/s import { AbstractCustomNode } from '../AbstractCustomNode'; import { JavaScriptObfuscator } from '../../JavaScriptObfuscator'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; import { StringArray } from '../../StringArray'; export class StringArrayCallsWrapper extends AbstractCustomNode { @@ -74,6 +73,22 @@ export class StringArrayCallsWrapper extends AbstractCustomNode { NodeAppender.insertNodeAtIndex(blockScopeNode, this.getNode(), 1); } + /** + * @returns {string} + */ + public getCode (): string { + const decodeNodeTemplate: string = this.getDecodeStringArrayTemplate(); + + return JavaScriptObfuscator.obfuscate( + StringArrayCallsWrapperTemplate().formatUnicorn({ + decodeNodeTemplate, + stringArrayCallsWrapperName: this.stringArrayCallsWrapperName, + stringArrayName: this.stringArrayName + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); + } + /** * @returns {string} */ @@ -125,22 +140,4 @@ export class StringArrayCallsWrapper extends AbstractCustomNode { return decodeStringArrayTemplate; } - - /** - * @returns {TStatement[]} - */ - protected getNodeStructure (): TStatement[] { - const decodeNodeTemplate: string = this.getDecodeStringArrayTemplate(); - - return NodeUtils.convertCodeToStructure( - JavaScriptObfuscator.obfuscate( - StringArrayCallsWrapperTemplate().formatUnicorn({ - decodeNodeTemplate, - stringArrayCallsWrapperName: this.stringArrayCallsWrapperName, - stringArrayName: this.stringArrayName - }), - NO_CUSTOM_NODES_PRESET - ).getObfuscatedCode() - ); - } } diff --git a/src/custom-nodes/string-array-nodes/StringArrayNode.ts b/src/custom-nodes/string-array-nodes/StringArrayNode.ts index 303097b3..bd13fc89 100644 --- a/src/custom-nodes/string-array-nodes/StringArrayNode.ts +++ b/src/custom-nodes/string-array-nodes/StringArrayNode.ts @@ -13,7 +13,6 @@ import { StringArrayTemplate } from '../../templates/custom-nodes/string-array-n import { AbstractCustomNode } from '../AbstractCustomNode'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; export class StringArrayNode extends AbstractCustomNode { /** @@ -71,6 +70,16 @@ export class StringArrayNode extends AbstractCustomNode { NodeAppender.prependNode(blockScopeNode, this.getNode()); } + /** + * @returns {string} + */ + public getCode (): string { + return StringArrayTemplate().formatUnicorn({ + stringArrayName: this.stringArrayName, + stringArray: this.stringArray.toString() + }); + } + /** * @returns {string} */ @@ -100,16 +109,4 @@ export class StringArrayNode extends AbstractCustomNode { public updateNodeData (data: string): void { this.stringArray.addToArray(data); } - - /** - * @returns {TStatement[]} - */ - protected getNodeStructure (): TStatement[] { - return NodeUtils.convertCodeToStructure( - StringArrayTemplate().formatUnicorn({ - stringArrayName: this.stringArrayName, - stringArray: this.stringArray.toString() - }) - ); - } } diff --git a/src/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.ts b/src/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.ts index 9f00be66..697ca0ad 100644 --- a/src/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.ts +++ b/src/custom-nodes/string-array-nodes/StringArrayRotateFunctionNode.ts @@ -1,7 +1,6 @@ import 'format-unicorn'; import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement'; -import { TStatement } from '../../types/TStatement'; import { IOptions } from '../../interfaces/IOptions'; @@ -15,7 +14,6 @@ import { StringArrayRotateFunctionTemplate } from '../../templates/custom-nodes/ import { AbstractCustomNode } from '../AbstractCustomNode'; import { JavaScriptObfuscator } from '../../JavaScriptObfuscator'; import { NodeAppender } from '../../node/NodeAppender'; -import { NodeUtils } from '../../node/NodeUtils'; import { StringArray } from '../../StringArray'; import { Utils } from '../../Utils'; @@ -71,16 +69,9 @@ export class StringArrayRotateFunctionNode extends AbstractCustomNode { } /** - * @returns {TStatement[]} + * @returns {string} */ - public getNode (): TStatement[] { - return super.getNode(); - } - - /** - * @returns {TStatement[]} - */ - protected getNodeStructure (): TStatement[] { + public getCode (): string { let code: string = '', timesName: string = Utils.getRandomVariableName(), whileFunctionName: string = Utils.getRandomVariableName(); @@ -94,17 +85,15 @@ export class StringArrayRotateFunctionNode extends AbstractCustomNode { code = `${whileFunctionName}(++${timesName})`; } - return NodeUtils.convertCodeToStructure( - JavaScriptObfuscator.obfuscate( - StringArrayRotateFunctionTemplate().formatUnicorn({ - code, - timesName, - stringArrayName: this.stringArrayName, - stringArrayRotateValue: Utils.decToHex(this.stringArrayRotateValue), - whileFunctionName - }), - NO_CUSTOM_NODES_PRESET - ).getObfuscatedCode() - ); + return JavaScriptObfuscator.obfuscate( + StringArrayRotateFunctionTemplate().formatUnicorn({ + code, + timesName, + stringArrayName: this.stringArrayName, + stringArrayRotateValue: Utils.decToHex(this.stringArrayRotateValue), + whileFunctionName + }), + NO_CUSTOM_NODES_PRESET + ).getObfuscatedCode(); } } diff --git a/src/interfaces/IControlFlowReplacer.d.ts b/src/interfaces/IControlFlowReplacer.d.ts new file mode 100644 index 00000000..71d7c3df --- /dev/null +++ b/src/interfaces/IControlFlowReplacer.d.ts @@ -0,0 +1,13 @@ +import * as ESTree from 'estree'; + +import { ICustomNode } from './custom-nodes/ICustomNode'; +import { ControlFlowStorage } from '../ControlFlowStorage'; + +export interface IControlFlowReplacer { + replace ( + node: ESTree.Node, + parentNode: ESTree.Node, + controlFlowStorage: ControlFlowStorage, + controlFlowStorageCustomNodeName: string + ): ICustomNode | undefined; +} diff --git a/src/interfaces/INodeControlFlowChanger.d.ts b/src/interfaces/INodeControlFlowChanger.d.ts new file mode 100644 index 00000000..8ca549ad --- /dev/null +++ b/src/interfaces/INodeControlFlowChanger.d.ts @@ -0,0 +1,9 @@ +import * as ESTree from 'estree'; + +export interface INodeControlFlowChanger { + /** + * @param node + * @param parentNode + */ + changeControlFlow (node: ESTree.Node, parentNode?: ESTree.Node): void; +} diff --git a/src/interfaces/IObfuscatorOptions.d.ts b/src/interfaces/IObfuscatorOptions.d.ts index eef2e4b1..a55a3b1b 100644 --- a/src/interfaces/IObfuscatorOptions.d.ts +++ b/src/interfaces/IObfuscatorOptions.d.ts @@ -3,6 +3,7 @@ import { TStringArrayEncoding } from '../types/TStringArrayEncoding'; export interface IObfuscatorOptions { compact?: boolean; + controlFlow?: boolean; debugProtection?: boolean; debugProtectionInterval?: boolean; disableConsoleOutput?: boolean; diff --git a/src/interfaces/IOptions.d.ts b/src/interfaces/IOptions.d.ts index 14757a3b..3a744271 100644 --- a/src/interfaces/IOptions.d.ts +++ b/src/interfaces/IOptions.d.ts @@ -3,6 +3,7 @@ import { TStringArrayEncoding } from '../types/TStringArrayEncoding'; export interface IOptions { readonly compact: boolean; + readonly controlFlow: boolean; readonly debugProtection: boolean; readonly debugProtectionInterval: boolean; readonly disableConsoleOutput: boolean; diff --git a/src/interfaces/custom-nodes/ICustomNode.d.ts b/src/interfaces/custom-nodes/ICustomNode.d.ts index 6e6b84fe..5d671b54 100644 --- a/src/interfaces/custom-nodes/ICustomNode.d.ts +++ b/src/interfaces/custom-nodes/ICustomNode.d.ts @@ -15,6 +15,11 @@ export interface ICustomNode { */ getAppendState (): AppendState; + /** + * @returns {string} + */ + getCode (): string; + /** * @returns ESTree.Node[] */ diff --git a/src/node-control-flow-changers/AbstractNodeControlFlowChanger.ts b/src/node-control-flow-changers/AbstractNodeControlFlowChanger.ts new file mode 100644 index 00000000..1f9567d1 --- /dev/null +++ b/src/node-control-flow-changers/AbstractNodeControlFlowChanger.ts @@ -0,0 +1,32 @@ +import * as ESTree from 'estree'; + +import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode'; +import { INodeControlFlowChanger } from '../interfaces/INodeControlFlowChanger'; +import { IOptions } from '../interfaces/IOptions'; + +export abstract class AbstractNodeControlFlowChanger implements INodeControlFlowChanger { + /** + * @type Map + */ + protected nodes: Map ; + + /** + * @type {IOptions} + */ + protected options: IOptions; + + /** + * @param nodes + * @param options + */ + constructor(nodes: Map , options: IOptions) { + this.nodes = nodes; + this.options = options; + } + + /** + * @param node + * @param parentNode + */ + public abstract changeControlFlow (node: ESTree.Node, parentNode?: ESTree.Node): void; +} diff --git a/src/node-control-flow-changers/FunctionControlFlowChanger.ts b/src/node-control-flow-changers/FunctionControlFlowChanger.ts new file mode 100644 index 00000000..043dbc6a --- /dev/null +++ b/src/node-control-flow-changers/FunctionControlFlowChanger.ts @@ -0,0 +1,87 @@ +import * as estraverse from 'estraverse'; +import * as ESTree from 'estree'; + +import { TControlFlowReplacer } from '../types/TControlFlowReplacer'; + +import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode'; +import { IOptions } from '../interfaces/IOptions'; + +import { NodeType } from '../enums/NodeType'; + +import { AbstractNodeControlFlowChanger } from './AbstractNodeControlFlowChanger'; +import { BinaryExpressionControlFlowReplacer } from './control-flow-replacers/BinaryExpressionControlFlowReplacer'; +import { ControlFlowStorage } from '../ControlFlowStorage'; +import { ControlFlowStorageNode } from '../custom-nodes/control-flow-storage-nodes/ControlFlowStorageNode'; +import { Node } from '../node/Node'; +import { NodeAppender } from '../node/NodeAppender'; +import { Utils } from '../Utils'; + +export class FunctionControlFlowChanger extends AbstractNodeControlFlowChanger { + /** + * @type {Map } + */ + private static controlFlowReplacers: Map = new Map ([ + [NodeType.BinaryExpression, BinaryExpressionControlFlowReplacer] + ]); + + /** + * @param nodes + * @param options + */ + constructor(nodes: Map , options: IOptions) { + super(nodes, options); + } + + /** + * @param functionNode + */ + public changeControlFlow (functionNode: ESTree.Function): void { + this.changeFunctionBodyControlFlow(functionNode); + } + + /** + * @param functionNode + */ + private changeFunctionBodyControlFlow (functionNode: ESTree.Function): void { + const controlFlowStorage: ControlFlowStorage = new ControlFlowStorage(); + const controlFlowStorageCustomNodeName: string = Utils.getRandomVariableName(6); + + if (!Node.isFunctionDeclarationNode(functionNode) && !Node.isFunctionExpressionNode(functionNode)) { + return; + } + + estraverse.replace(functionNode.body, { + enter: (node: ESTree.Node, parentNode: ESTree.Node): any => { + const controlFlowReplacerConstructor: TControlFlowReplacer | undefined = FunctionControlFlowChanger.controlFlowReplacers + .get(node.type); + + if (!controlFlowReplacerConstructor) { + return; + } + + const controlFlowStorageCallCustomNode: ICustomNode | undefined = new controlFlowReplacerConstructor( + this.nodes, + this.options + ).replace(node, parentNode, controlFlowStorage, controlFlowStorageCustomNodeName); + + if (!controlFlowStorageCallCustomNode) { + return; + } + + // controlFlowStorageCallCustomNode will always has only one TStatement node, + // so we can get it by index `0` + // also we need to `expression` property of `ExpressionStatement` node because bug: + // https://github.com/estools/escodegen/issues/289 + return (controlFlowStorageCallCustomNode.getNode()[0]).expression; + } + }); + + const controlFlowStorageCustomNode: ControlFlowStorageNode = new ControlFlowStorageNode( + controlFlowStorage, + controlFlowStorageCustomNodeName, + this.options + ); + + NodeAppender.prependNode(functionNode.body, controlFlowStorageCustomNode.getNode()); + } +} diff --git a/src/node-control-flow-changers/control-flow-replacers/AbstractControlFlowReplacer.ts b/src/node-control-flow-changers/control-flow-replacers/AbstractControlFlowReplacer.ts new file mode 100644 index 00000000..e7752a2e --- /dev/null +++ b/src/node-control-flow-changers/control-flow-replacers/AbstractControlFlowReplacer.ts @@ -0,0 +1,53 @@ +import * as ESTree from 'estree'; + +import { IControlFlowReplacer } from '../../interfaces/IControlFlowReplacer'; +import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode'; +import { IOptions } from '../../interfaces/IOptions'; + +import { ControlFlowStorage } from '../../ControlFlowStorage'; +import { Utils } from '../../Utils'; + +export abstract class AbstractControlFlowReplacer implements IControlFlowReplacer { + /** + * @type Map + */ + protected nodes: Map ; + + /** + * @type {IOptions} + */ + protected options : IOptions; + + /** + * @param nodes + * @param options + */ + constructor (nodes: Map , options: IOptions) { + this.nodes = nodes; + this.options = options; + } + + /** + * @returns {string} + */ + protected static getStorageKey (): string { + return Utils.getRandomGenerator().string({ + length: 3, + pool: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' + }); + } + + /** + * @param node + * @param parentNode + * @param controlFlowStorage + * @param controlFlowStorageCustomNodeName + * @returns {ICustomNode | undefined} + */ + public abstract replace ( + node: ESTree.Node, + parentNode: ESTree.Node, + controlFlowStorage: ControlFlowStorage, + controlFlowStorageCustomNodeName: string + ): ICustomNode | undefined; +} diff --git a/src/node-control-flow-changers/control-flow-replacers/BinaryExpressionControlFlowReplacer.ts b/src/node-control-flow-changers/control-flow-replacers/BinaryExpressionControlFlowReplacer.ts new file mode 100644 index 00000000..e259e8b7 --- /dev/null +++ b/src/node-control-flow-changers/control-flow-replacers/BinaryExpressionControlFlowReplacer.ts @@ -0,0 +1,83 @@ +import * as escodegen from 'escodegen'; +import * as ESTree from 'estree'; + +import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode'; + +import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer'; +import { BinaryExpressionSumFunctionNode } from '../../custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionNode'; +import { BinaryExpressionSubtractFunctionNode } from '../../custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionNode'; +import { BinaryExpressionMultiplyFunctionNode } from '../../custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionNode'; +import { BinaryExpressionDivideFunctionNode } from '../../custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionNode'; +import { BinaryExpressionExponentiationFunctionNode } from '../../custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentiationFunctionNode'; +import { ControlFlowStorage } from '../../ControlFlowStorage'; +import { ControlFlowStorageCallNode } from '../../custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallNode'; + +export class BinaryExpressionControlFlowReplacer extends AbstractControlFlowReplacer { + /** + * @param expressionNode + * @returns {string} + */ + private static getExpressionValue (expressionNode: ESTree.Expression): string { + return escodegen.generate(expressionNode, { + sourceMapWithCode: true + }).code; + } + + /** + * @param binaryExpressionNode + * @param parentNode + * @param controlFlowStorage + * @param controlFlowStorageCustomNodeName + * @returns {ICustomNode | undefined} + */ + public replace ( + binaryExpressionNode: ESTree.BinaryExpression, + parentNode: ESTree.Node, + controlFlowStorage: ControlFlowStorage, + controlFlowStorageCustomNodeName: string + ): ICustomNode | undefined { + let binaryExpressionFunctionNode: ICustomNode; + + switch (binaryExpressionNode.operator) { + case '+': + binaryExpressionFunctionNode = new BinaryExpressionSumFunctionNode(this.options); + + break; + + case '-': + binaryExpressionFunctionNode = new BinaryExpressionSubtractFunctionNode(this.options); + + break; + + case '*': + binaryExpressionFunctionNode = new BinaryExpressionMultiplyFunctionNode(this.options); + + break; + + case '/': + binaryExpressionFunctionNode = new BinaryExpressionDivideFunctionNode(this.options); + + break; + + case '**': + binaryExpressionFunctionNode = new BinaryExpressionExponentiationFunctionNode(this.options); + + break; + + default: + return; + } + + const key: string = AbstractControlFlowReplacer.getStorageKey(); + + controlFlowStorage.addToStorage(key, binaryExpressionFunctionNode); + + return new ControlFlowStorageCallNode( + controlFlowStorageCustomNodeName, + key, + BinaryExpressionControlFlowReplacer.getExpressionValue(binaryExpressionNode.left), + BinaryExpressionControlFlowReplacer.getExpressionValue(binaryExpressionNode.right), + this.options + ); + } +} diff --git a/src/options/Options.ts b/src/options/Options.ts index 49eec25d..347be47f 100644 --- a/src/options/Options.ts +++ b/src/options/Options.ts @@ -41,6 +41,12 @@ export class Options implements IOptions { @IsBoolean() public readonly compact: boolean; + /** + * @type {boolean} + */ + @IsBoolean() + public readonly controlFlow: boolean; + /** * @type {boolean} */ diff --git a/src/preset-options/DefaultPreset.ts b/src/preset-options/DefaultPreset.ts index 1d6a5fe1..7fff5f16 100644 --- a/src/preset-options/DefaultPreset.ts +++ b/src/preset-options/DefaultPreset.ts @@ -4,6 +4,7 @@ import { SourceMapMode } from '../enums/SourceMapMode'; export const DEFAULT_PRESET: IObfuscatorOptions = Object.freeze({ compact: true, + controlFlow: false, debugProtection: false, debugProtectionInterval: false, disableConsoleOutput: true, diff --git a/src/preset-options/NoCustomNodesPreset.ts b/src/preset-options/NoCustomNodesPreset.ts index f8f000a3..6c3f3752 100644 --- a/src/preset-options/NoCustomNodesPreset.ts +++ b/src/preset-options/NoCustomNodesPreset.ts @@ -4,6 +4,7 @@ import { SourceMapMode } from '../enums/SourceMapMode'; export const NO_CUSTOM_NODES_PRESET: IObfuscatorOptions = Object.freeze({ compact: true, + controlFlow: false, debugProtection: false, debugProtectionInterval: false, disableConsoleOutput: false, diff --git a/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionTemplate.ts b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionTemplate.ts new file mode 100644 index 00000000..c75d402b --- /dev/null +++ b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionDivideFunctionTemplate.ts @@ -0,0 +1,10 @@ +/** + * @returns {string} + */ +export function BinaryExpressionDivideFunctionTemplate (): string { + return ` + function {functionName} (x, y) { + return x / y; + } + `; +} diff --git a/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentitionFunctionTemplate.ts b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentitionFunctionTemplate.ts new file mode 100644 index 00000000..25479ed9 --- /dev/null +++ b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionExponentitionFunctionTemplate.ts @@ -0,0 +1,10 @@ +/** + * @returns {string} + */ +export function BinaryExpressionExponentiationFunctionTemplate (): string { + return ` + function {functionName} (x, y) { + return Math.pow(x, y); + } + `; +} diff --git a/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionTemplate.ts b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionTemplate.ts new file mode 100644 index 00000000..7c4d33a6 --- /dev/null +++ b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionMultiplyFunctionTemplate.ts @@ -0,0 +1,10 @@ +/** + * @returns {string} + */ +export function BinaryExpressionMultiplyFunctionTemplate (): string { + return ` + function {functionName} (x, y) { + return x * y; + } + `; +} diff --git a/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionTemplate.ts b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionTemplate.ts new file mode 100644 index 00000000..192046eb --- /dev/null +++ b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSubtractFunctionTemplate.ts @@ -0,0 +1,10 @@ +/** + * @returns {string} + */ +export function BinaryExpressionSubtractFunctionTemplate (): string { + return ` + function {functionName} (x, y) { + return x - y; + } + `; +} diff --git a/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionTemplate.ts b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionTemplate.ts new file mode 100644 index 00000000..428370a3 --- /dev/null +++ b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/BinaryExpressionSumFunctionTemplate.ts @@ -0,0 +1,10 @@ +/** + * @returns {string} + */ +export function BinaryExpressionSumFunctionTemplate (): string { + return ` + function {functionName} (x, y) { + return x + y; + } + `; +} diff --git a/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallTemplate.ts b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallTemplate.ts new file mode 100644 index 00000000..a1147cf1 --- /dev/null +++ b/src/templates/custom-nodes/control-flow-replacers-nodes/binary-expression-control-flow-replacer-nodes/ControlFlowStorageCallTemplate.ts @@ -0,0 +1,6 @@ +/** + * @returns {string} + */ +export function ControlFlowStorageCallTemplate (): string { + return '{controlFlowStorageName}.{controlFlowStorageKey}({leftValue}, {rightValue})'; +} diff --git a/src/templates/custom-nodes/control-flow-storage-nodes/ControlFlowStorageTemplate.ts b/src/templates/custom-nodes/control-flow-storage-nodes/ControlFlowStorageTemplate.ts new file mode 100644 index 00000000..632b6421 --- /dev/null +++ b/src/templates/custom-nodes/control-flow-storage-nodes/ControlFlowStorageTemplate.ts @@ -0,0 +1,8 @@ +/** + * @returns {string} + */ +export function ControlFlowStorageTemplate (): string { + return ` + var {controlFlowStorageName} = {controlFlowStorage}; + `; +} diff --git a/src/types/TControlFlowReplacer.d.ts b/src/types/TControlFlowReplacer.d.ts new file mode 100644 index 00000000..b80db1e5 --- /dev/null +++ b/src/types/TControlFlowReplacer.d.ts @@ -0,0 +1,5 @@ +import { IControlFlowReplacer } from '../interfaces/IControlFlowReplacer'; +import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode'; +import { IOptions } from '../interfaces/IOptions'; + +export type TControlFlowReplacer = (new (nodes: Map , options: IOptions) => IControlFlowReplacer); diff --git a/src/types/TNodeControlFlowChanger.d.ts b/src/types/TNodeControlFlowChanger.d.ts new file mode 100644 index 00000000..373473e5 --- /dev/null +++ b/src/types/TNodeControlFlowChanger.d.ts @@ -0,0 +1,5 @@ +import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode'; +import { INodeControlFlowChanger } from '../interfaces/INodeControlFlowChanger'; +import { IOptions } from '../interfaces/IOptions'; + +export type TNodeControlFlowChanger = (new (nodes: Map , options: IOptions) => INodeControlFlowChanger); diff --git a/src/types/custom-nodes/TControlFlowStorageNode.d.ts b/src/types/custom-nodes/TControlFlowStorageNode.d.ts new file mode 100644 index 00000000..a1893192 --- /dev/null +++ b/src/types/custom-nodes/TControlFlowStorageNode.d.ts @@ -0,0 +1,4 @@ +import { ICustomNodeWithData } from '../../interfaces/custom-nodes/ICustomNodeWithData'; +import { ICustomNodeWithIdentifier } from '../../interfaces/custom-nodes/ICustomNodeWithIdentifier'; + +export type TControlFlowStorageNode = ICustomNodeWithData & ICustomNodeWithIdentifier; diff --git a/test/dev/dev.ts b/test/dev/dev.ts index f9502967..ff8104af 100644 --- a/test/dev/dev.ts +++ b/test/dev/dev.ts @@ -1,4 +1,5 @@ 'use strict'; +import { NO_CUSTOM_NODES_PRESET } from '../../src/preset-options/NoCustomNodesPreset'; if (!(global)._babelPolyfill) { require('babel-polyfill'); @@ -66,13 +67,14 @@ if (!(global)._babelPolyfill) { } catch (error) { console.log(error); } + + var left = 5; + console.log(left + 15); })(); `, - { - disableConsoleOutput: false, - selfDefending: true, - stringArrayEncoding: 'rc4' - } + Object.assign({}, NO_CUSTOM_NODES_PRESET, { + controlFlow: true + }) ).getObfuscatedCode(); console.log(obfuscatedCode); diff --git a/test/fixtures/compile-performance.js b/test/fixtures/compile-performance.js index 1aaef076..21682938 100644 --- a/test/fixtures/compile-performance.js +++ b/test/fixtures/compile-performance.js @@ -6371,7 +6371,7 @@ /* 42 */ /***/ function(module, exports, __webpack_require__) { -// to indexed object, toObject with fallback for non-array-like ES3 strings +// to indexed object, toString with fallback for non-array-like ES3 strings var IObject = __webpack_require__(118) , defined = __webpack_require__(59); module.exports = function(it){ diff --git a/test/functional-tests/node-obfuscators/CatchClauseObfuscator.spec.ts b/test/functional-tests/node-obfuscators/CatchClauseObfuscator.spec.ts index 7e8a07ce..ab0f0d8d 100644 --- a/test/functional-tests/node-obfuscators/CatchClauseObfuscator.spec.ts +++ b/test/functional-tests/node-obfuscators/CatchClauseObfuscator.spec.ts @@ -9,7 +9,7 @@ import { JavaScriptObfuscator } from '../../../src/JavaScriptObfuscator'; const assert: Chai.AssertStatic = require('chai').assert; describe('CatchClauseObfuscator', () => { - describe('obfuscateNode (catchClauseNode: ESTree.CatchClause): void', () => { + describe('changeControlFlow (catchClauseNode: ESTree.CatchClause): void', () => { const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( readFileAsString('./test/fixtures/node-obfuscators/catch-clause-obfuscator/catch-clause-obfuscator.js'), Object.assign({}, NO_CUSTOM_NODES_PRESET) diff --git a/test/functional-tests/node-obfuscators/LabeledStatementObfuscator.spec.ts b/test/functional-tests/node-obfuscators/LabeledStatementObfuscator.spec.ts index 7e567178..298347d6 100644 --- a/test/functional-tests/node-obfuscators/LabeledStatementObfuscator.spec.ts +++ b/test/functional-tests/node-obfuscators/LabeledStatementObfuscator.spec.ts @@ -9,7 +9,7 @@ import { JavaScriptObfuscator } from '../../../src/JavaScriptObfuscator'; const assert: Chai.AssertStatic = require('chai').assert; describe('LabeledStatementObfuscator', () => { - describe('obfuscateNode (labeledStatementNode: ESTree.LabeledStatement): void', () => { + describe('changeControlFlow (labeledStatementNode: ESTree.LabeledStatement): void', () => { const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate( readFileAsString('./test/fixtures/node-obfuscators/labeled-statement-obfuscator/labeled-statement-obfuscator.js'), Object.assign({}, NO_CUSTOM_NODES_PRESET) diff --git a/test/unit-tests/node-obfuscators/FunctionDeclarationObfuscator.spec.ts b/test/unit-tests/node-obfuscators/FunctionDeclarationObfuscator.spec.ts index eb0fb824..4008ab67 100644 --- a/test/unit-tests/node-obfuscators/FunctionDeclarationObfuscator.spec.ts +++ b/test/unit-tests/node-obfuscators/FunctionDeclarationObfuscator.spec.ts @@ -11,7 +11,7 @@ import { Options } from '../../../src/options/Options'; const assert: Chai.AssertStatic = require('chai').assert; describe('FunctionDeclarationObfuscator', () => { - describe('obfuscateNode (functionDeclarationNode: IFunctionDeclarationNode, parentNode: INode): void', () => { + describe('changeControlFlow (functionDeclarationNode: IFunctionDeclarationNode, parentNode: INode): void', () => { let expressionStatementNode: ESTree.ExpressionStatement, functionDeclarationObfuscator: FunctionDeclarationObfuscator, functionDeclarationNode: ESTree.FunctionDeclaration, diff --git a/test/unit-tests/node-obfuscators/FunctionObfuscator.spec.ts b/test/unit-tests/node-obfuscators/FunctionObfuscator.spec.ts index 52671a73..a80548c1 100644 --- a/test/unit-tests/node-obfuscators/FunctionObfuscator.spec.ts +++ b/test/unit-tests/node-obfuscators/FunctionObfuscator.spec.ts @@ -12,7 +12,7 @@ import { Options } from '../../../src/options/Options'; const assert: Chai.AssertStatic = require('chai').assert; describe('FunctionObfuscator', () => { - describe('obfuscateNode (functionNode: IFunctionNode): void', () => { + describe('changeControlFlow (functionNode: IFunctionNode): void', () => { let blockStatementNode: ESTree.BlockStatement, expressionStatementNode1: ESTree.ExpressionStatement, expressionStatementNode2: ESTree.ExpressionStatement,