From 171234250fb67496837dd0210cb52e97e3996434 Mon Sep 17 00:00:00 2001 From: sanex3339 Date: Sat, 28 May 2016 14:31:25 +0300 Subject: [PATCH] version 0.5.0 --- dist/index.js | 3 ++- dist/src/Obfuscator.js | 2 +- ...nslator.js => UnicodeArrayCallsWrapper.js} | 12 ++++++------ .../src/node-groups/UnicodeArrayNodesGroup.js | 9 ++++----- .../src/node-obfuscators/LiteralObfuscator.js | 2 +- .../MemberExpressionObfuscator.js | 4 ++-- .../MethodDefinitionObfuscator.js | 2 +- dist/src/node-obfuscators/NodeObfuscator.js | 10 +++++++--- index.ts | 3 ++- package.json | 2 +- readme.md | 12 ++++++++++++ src/Obfuscator.ts | 2 +- ...nslator.ts => UnicodeArrayCallsWrapper.ts} | 14 +++++++------- src/node-groups/UnicodeArrayNodesGroup.ts | 17 ++++++++++------- src/node-obfuscators/LiteralObfuscator.ts | 2 +- .../MemberExpressionObfuscator.ts | 4 ++-- .../MethodDefinitionObfuscator.ts | 2 +- src/node-obfuscators/NodeObfuscator.ts | 19 +++++++++++++++---- tests/dev-test.ts | 2 +- 19 files changed, 77 insertions(+), 46 deletions(-) rename dist/src/custom-nodes/unicode-array-nodes/{UnicodeArrayTranslator.js => UnicodeArrayCallsWrapper.js} (76%) rename src/custom-nodes/unicode-array-nodes/{UnicodeArrayTranslator.ts => UnicodeArrayCallsWrapper.ts} (83%) diff --git a/dist/index.js b/dist/index.js index 1482fe1a..aeecf703 100644 --- a/dist/index.js +++ b/dist/index.js @@ -22,7 +22,8 @@ JavaScriptObfuscator.defaultOptions = { debugProtection: false, debugProtectionInterval: false, disableConsoleOutput: true, - rotateUnicodeArray: true + rotateUnicodeArray: true, + wrapUnicodeArrayCalls: false }; JavaScriptObfuscator.escodegenParams = { verbatim: 'x-verbatim-property' diff --git a/dist/src/Obfuscator.js b/dist/src/Obfuscator.js index 22054375..bba98374 100644 --- a/dist/src/Obfuscator.js +++ b/dist/src/Obfuscator.js @@ -70,7 +70,7 @@ class Obfuscator { return; } this.nodeObfuscators.get(node.type).forEach((obfuscator) => { - new obfuscator(this.nodes).obfuscateNode(node, parentNode); + new obfuscator(this.nodes, this.options).obfuscateNode(node, parentNode); }); } obfuscate(node) { diff --git a/dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayTranslator.js b/dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.js similarity index 76% rename from dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayTranslator.js rename to dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.js index 723673b3..6794f2e1 100644 --- a/dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayTranslator.js +++ b/dist/src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.js @@ -4,11 +4,11 @@ const AppendState_1 = require("../../enums/AppendState"); const Node_1 = require('../Node'); const NodeUtils_1 = require("../../NodeUtils"); const Utils_1 = require("../../Utils"); -class UnicodeArrayTranslator extends Node_1.Node { - constructor(unicodeArrayTranslatorName, unicodeArrayName, unicodeArray) { +class UnicodeArrayCallsWrapper extends Node_1.Node { + constructor(unicodeArrayCallsWrapperName, unicodeArrayName, unicodeArray) { super(); this.appendState = AppendState_1.AppendState.AfterObfuscation; - this.unicodeArrayTranslatorName = unicodeArrayTranslatorName; + this.unicodeArrayCallsWrapperName = unicodeArrayCallsWrapperName; this.unicodeArrayName = unicodeArrayName; this.unicodeArray = unicodeArray; this.node = this.getNodeStructure(); @@ -17,7 +17,7 @@ class UnicodeArrayTranslator extends Node_1.Node { NodeUtils_1.NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1); } getNodeIdentifier() { - return this.unicodeArrayTranslatorName; + return this.unicodeArrayCallsWrapperName; } ; getNode() { @@ -28,7 +28,7 @@ class UnicodeArrayTranslator extends Node_1.Node { } getNodeStructure() { let keyName = Utils_1.Utils.getRandomVariableName(), node = esprima.parse(` - var ${this.unicodeArrayTranslatorName} = function (${keyName}) { + var ${this.unicodeArrayCallsWrapperName} = function (${keyName}) { return ${this.unicodeArrayName}[[][${Utils_1.Utils.stringToUnicode('filter')}][${Utils_1.Utils.stringToUnicode('constructor')}](${Utils_1.Utils.stringToUnicode('return this')})()[${Utils_1.Utils.stringToUnicode('parseInt')}](${keyName})] }; `); @@ -36,4 +36,4 @@ class UnicodeArrayTranslator extends Node_1.Node { return NodeUtils_1.NodeUtils.getBlockScopeNodeByIndex(node); } } -exports.UnicodeArrayTranslator = UnicodeArrayTranslator; +exports.UnicodeArrayCallsWrapper = UnicodeArrayCallsWrapper; diff --git a/dist/src/node-groups/UnicodeArrayNodesGroup.js b/dist/src/node-groups/UnicodeArrayNodesGroup.js index 1e05faa3..08cd81f5 100644 --- a/dist/src/node-groups/UnicodeArrayNodesGroup.js +++ b/dist/src/node-groups/UnicodeArrayNodesGroup.js @@ -1,9 +1,9 @@ "use strict"; const NodesGroup_1 = require('./NodesGroup'); +const UnicodeArrayCallsWrapper_1 = require("../custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper"); const UnicodeArrayNode_1 = require('../custom-nodes/unicode-array-nodes/UnicodeArrayNode'); const UnicodeArrayRotateFunctionNode_1 = require('../custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode'); const Utils_1 = require('../Utils'); -const UnicodeArrayTranslator_1 = require("../custom-nodes/unicode-array-nodes/UnicodeArrayTranslator"); class UnicodeArrayNodesGroup extends NodesGroup_1.NodesGroup { constructor(options) { super(); @@ -16,12 +16,11 @@ class UnicodeArrayNodesGroup extends NodesGroup_1.NodesGroup { [ 'unicodeArrayNode', unicodeArrayNode - ], - [ - 'unicodeArrayTranslator', - new UnicodeArrayTranslator_1.UnicodeArrayTranslator(this.unicodeArrayTranslatorName, this.unicodeArrayName, unicodeArray) ] ]); + if (this.options['wrapUnicodeArrayCalls']) { + this.nodes.set('unicodeArrayCallsWrapper', new UnicodeArrayCallsWrapper_1.UnicodeArrayCallsWrapper(this.unicodeArrayTranslatorName, this.unicodeArrayName, unicodeArray)); + } if (this.options['rotateUnicodeArray']) { this.nodes.set('unicodeArrayRotateFunctionNode', new UnicodeArrayRotateFunctionNode_1.UnicodeArrayRotateFunctionNode(this.unicodeArrayName, unicodeArray, this.unicodeArrayRotateValue)); } diff --git a/dist/src/node-obfuscators/LiteralObfuscator.js b/dist/src/node-obfuscators/LiteralObfuscator.js index 38a0c172..afd1434e 100644 --- a/dist/src/node-obfuscators/LiteralObfuscator.js +++ b/dist/src/node-obfuscators/LiteralObfuscator.js @@ -19,7 +19,7 @@ class LiteralObfuscator extends NodeObfuscator_1.NodeObfuscator { content = this.replaceLiteralNumberByHexadecimalValue(literalNode.value); break; case 'string': - content = this.replaceLiteralStringByUnicodeArrayTranslatorCall(literalNode.value); + content = this.replaceLiteralStringByUnicodeArrayCall(literalNode.value); break; default: return; diff --git a/dist/src/node-obfuscators/MemberExpressionObfuscator.js b/dist/src/node-obfuscators/MemberExpressionObfuscator.js index 3a55c17c..67220559 100644 --- a/dist/src/node-obfuscators/MemberExpressionObfuscator.js +++ b/dist/src/node-obfuscators/MemberExpressionObfuscator.js @@ -26,7 +26,7 @@ class MemberExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator { let nodeValue = node.name, literalNode = { raw: `'${nodeValue}'`, 'x-verbatim-property': { - content: this.replaceLiteralStringByUnicodeArrayTranslatorCall(nodeValue), + content: this.replaceLiteralStringByUnicodeArrayCall(nodeValue), precedence: escodegen.Precedence.Primary }, type: NodeType_1.NodeType.Literal, @@ -42,7 +42,7 @@ class MemberExpressionObfuscator extends NodeObfuscator_1.NodeObfuscator { break; } node['x-verbatim-property'] = { - content: this.replaceLiteralStringByUnicodeArrayTranslatorCall(node.value), + content: this.replaceLiteralStringByUnicodeArrayCall(node.value), precedence: escodegen.Precedence.Primary }; break; diff --git a/dist/src/node-obfuscators/MethodDefinitionObfuscator.js b/dist/src/node-obfuscators/MethodDefinitionObfuscator.js index fe6ba14d..e6007815 100644 --- a/dist/src/node-obfuscators/MethodDefinitionObfuscator.js +++ b/dist/src/node-obfuscators/MethodDefinitionObfuscator.js @@ -18,7 +18,7 @@ class MethodDefinitionObfuscator extends NodeObfuscator_1.NodeObfuscator { !Utils_1.Utils.arrayContains(this.ignoredNames, node.name) && methodDefinitionNode.computed === false) { methodDefinitionNode.computed = true; - node.name = this.replaceLiteralStringByUnicodeArrayTranslatorCall(node.name); + node.name = this.replaceLiteralStringByUnicodeArrayCall(node.name); return; } return estraverse.VisitorOption.Skip; diff --git a/dist/src/node-obfuscators/NodeObfuscator.js b/dist/src/node-obfuscators/NodeObfuscator.js index 1d30913a..92ae72df 100644 --- a/dist/src/node-obfuscators/NodeObfuscator.js +++ b/dist/src/node-obfuscators/NodeObfuscator.js @@ -3,8 +3,9 @@ const JSFuck_1 = require("../enums/JSFuck"); const NodeUtils_1 = require("../NodeUtils"); const Utils_1 = require('../Utils'); class NodeObfuscator { - constructor(nodes) { + constructor(nodes, options = {}) { this.nodes = nodes; + this.options = options; } replaceNodeIdentifierByNewValue(node, parentNode, namesMap) { if (NodeUtils_1.NodeUtils.isIdentifierNode(node) && namesMap.has(node.name)) { @@ -25,7 +26,7 @@ class NodeObfuscator { } return `${prefix}${Utils_1.Utils.decToHex(nodeValue)}`; } - replaceLiteralStringByUnicodeArrayTranslatorCall(nodeValue) { + replaceLiteralStringByUnicodeArrayCall(nodeValue) { let value = Utils_1.Utils.stringToUnicode(nodeValue), unicodeArray = this.nodes.get('unicodeArrayNode').getNodeData(), sameIndex = unicodeArray.indexOf(value), index, hexadecimalIndex; if (sameIndex < 0) { index = unicodeArray.length; @@ -35,7 +36,10 @@ class NodeObfuscator { index = sameIndex; } hexadecimalIndex = this.replaceLiteralNumberByHexadecimalValue(index); - return `${this.nodes.get('unicodeArrayTranslator').getNodeIdentifier()}('${hexadecimalIndex}')`; + if (this.options['wrapUnicodeArrayCalls']) { + return `${this.nodes.get('unicodeArrayCallsWrapper').getNodeIdentifier()}('${hexadecimalIndex}')`; + } + return `${this.nodes.get('unicodeArrayNode').getNodeIdentifier()}[${hexadecimalIndex}]`; } } exports.NodeObfuscator = NodeObfuscator; diff --git a/index.ts b/index.ts index e1347900..170a842b 100644 --- a/index.ts +++ b/index.ts @@ -16,7 +16,8 @@ class JavaScriptObfuscator { debugProtection: false, debugProtectionInterval: false, disableConsoleOutput: true, - rotateUnicodeArray: true + rotateUnicodeArray: true, + wrapUnicodeArrayCalls: false }; /** diff --git a/package.json b/package.json index 03a5f74a..1b352d6a 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "javascript-obfuscator", - "version": "0.4.3", + "version": "0.5.0", "description": "JavaScript obfuscator", "keywords": [ "obfuscator", diff --git a/readme.md b/readme.md index 395141a4..cbe932b7 100644 --- a/readme.md +++ b/readme.md @@ -101,3 +101,15 @@ which will rotate array values back to their original indexes. This option affected only on visual code organisation, because we can easily get original array during debug process. Not recommended for small source code, because helper function will attract attention. + +####wrapUnicodeArrayCalls +Type: `boolean` Default: `false` + +#####This option have huge affect on performance! Use this option only on small pieces of code (< 5000 LOC) + +Instead using direct calls to `unicodeArray` items `var t = _0x43a123[0x0]`, +when index `0x0` can be easy reverted to `0` with few js beautifiers, this option wrap all calls to special function instead. + +```javascript +`var t = _0x12a634('0x0')` +``` diff --git a/src/Obfuscator.ts b/src/Obfuscator.ts index cc654dae..9dcbf491 100644 --- a/src/Obfuscator.ts +++ b/src/Obfuscator.ts @@ -125,7 +125,7 @@ export class Obfuscator { } this.nodeObfuscators.get(node.type).forEach((obfuscator: Function) => { - new ( obfuscator(this.nodes)).obfuscateNode(node, parentNode); + new ( obfuscator(this.nodes, this.options)).obfuscateNode(node, parentNode); }); } diff --git a/src/custom-nodes/unicode-array-nodes/UnicodeArrayTranslator.ts b/src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.ts similarity index 83% rename from src/custom-nodes/unicode-array-nodes/UnicodeArrayTranslator.ts rename to src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.ts index 5b4efc48..2aaf83d0 100644 --- a/src/custom-nodes/unicode-array-nodes/UnicodeArrayTranslator.ts +++ b/src/custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper.ts @@ -10,7 +10,7 @@ import { Node } from '../Node'; import { NodeUtils } from "../../NodeUtils"; import { Utils } from "../../Utils"; -export class UnicodeArrayTranslator extends Node { +export class UnicodeArrayCallsWrapper extends Node { /** * @type {AppendState} */ @@ -29,21 +29,21 @@ export class UnicodeArrayTranslator extends Node { /** * @type {string} */ - private unicodeArrayTranslatorName: string; + private unicodeArrayCallsWrapperName: string; /** - * @param unicodeArrayTranslatorName + * @param unicodeArrayCallsWrapperName * @param unicodeArrayName * @param unicodeArray */ constructor ( - unicodeArrayTranslatorName: string, + unicodeArrayCallsWrapperName: string, unicodeArrayName: string, unicodeArray: string[] ) { super(); - this.unicodeArrayTranslatorName = unicodeArrayTranslatorName; + this.unicodeArrayCallsWrapperName = unicodeArrayCallsWrapperName; this.unicodeArrayName = unicodeArrayName; this.unicodeArray = unicodeArray; @@ -61,7 +61,7 @@ export class UnicodeArrayTranslator extends Node { * @returns {string} */ public getNodeIdentifier (): string { - return this.unicodeArrayTranslatorName; + return this.unicodeArrayCallsWrapperName; }; /** @@ -81,7 +81,7 @@ export class UnicodeArrayTranslator extends Node { protected getNodeStructure (): any { let keyName: string = Utils.getRandomVariableName(), node: INode = esprima.parse(` - var ${this.unicodeArrayTranslatorName} = function (${keyName}) { + var ${this.unicodeArrayCallsWrapperName} = function (${keyName}) { return ${this.unicodeArrayName}[[][${Utils.stringToUnicode('filter')}][${Utils.stringToUnicode('constructor')}](${Utils.stringToUnicode('return this')})()[${Utils.stringToUnicode('parseInt')}](${keyName})] }; `); diff --git a/src/node-groups/UnicodeArrayNodesGroup.ts b/src/node-groups/UnicodeArrayNodesGroup.ts index 78473a3a..7813f1d8 100644 --- a/src/node-groups/UnicodeArrayNodesGroup.ts +++ b/src/node-groups/UnicodeArrayNodesGroup.ts @@ -1,10 +1,10 @@ import { ICustomNode } from '../interfaces/ICustomNode'; import { NodesGroup } from './NodesGroup'; +import { UnicodeArrayCallsWrapper } from "../custom-nodes/unicode-array-nodes/UnicodeArrayCallsWrapper"; import { UnicodeArrayNode } from '../custom-nodes/unicode-array-nodes/UnicodeArrayNode'; import { UnicodeArrayRotateFunctionNode } from '../custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode'; import { Utils } from '../Utils'; -import {UnicodeArrayTranslator} from "../custom-nodes/unicode-array-nodes/UnicodeArrayTranslator"; export class UnicodeArrayNodesGroup extends NodesGroup { /** @@ -45,16 +45,19 @@ export class UnicodeArrayNodesGroup extends NodesGroup { [ 'unicodeArrayNode', unicodeArrayNode - ], - [ - 'unicodeArrayTranslator', - new UnicodeArrayTranslator( + ] + ]); + + if (this.options['wrapUnicodeArrayCalls']) { + this.nodes.set( + 'unicodeArrayCallsWrapper', + new UnicodeArrayCallsWrapper( this.unicodeArrayTranslatorName, this.unicodeArrayName, unicodeArray ) - ] - ]); + ); + } if (this.options['rotateUnicodeArray']) { this.nodes.set( diff --git a/src/node-obfuscators/LiteralObfuscator.ts b/src/node-obfuscators/LiteralObfuscator.ts index bc0d2988..16af76d7 100644 --- a/src/node-obfuscators/LiteralObfuscator.ts +++ b/src/node-obfuscators/LiteralObfuscator.ts @@ -35,7 +35,7 @@ export class LiteralObfuscator extends NodeObfuscator { case 'string': - content = this.replaceLiteralStringByUnicodeArrayTranslatorCall(literalNode.value); + content = this.replaceLiteralStringByUnicodeArrayCall(literalNode.value); break; diff --git a/src/node-obfuscators/MemberExpressionObfuscator.ts b/src/node-obfuscators/MemberExpressionObfuscator.ts index b56627d7..734da271 100644 --- a/src/node-obfuscators/MemberExpressionObfuscator.ts +++ b/src/node-obfuscators/MemberExpressionObfuscator.ts @@ -53,7 +53,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator { literalNode: ILiteralNode = { raw: `'${nodeValue}'`, 'x-verbatim-property': { - content : this.replaceLiteralStringByUnicodeArrayTranslatorCall(nodeValue), + content : this.replaceLiteralStringByUnicodeArrayCall(nodeValue), precedence: escodegen.Precedence.Primary }, type: NodeType.Literal, @@ -82,7 +82,7 @@ export class MemberExpressionObfuscator extends NodeObfuscator { } node['x-verbatim-property'] = { - content : this.replaceLiteralStringByUnicodeArrayTranslatorCall(node.value), + content : this.replaceLiteralStringByUnicodeArrayCall(node.value), precedence: escodegen.Precedence.Primary }; diff --git a/src/node-obfuscators/MethodDefinitionObfuscator.ts b/src/node-obfuscators/MethodDefinitionObfuscator.ts index 3fd7ea7c..b4c9929f 100644 --- a/src/node-obfuscators/MethodDefinitionObfuscator.ts +++ b/src/node-obfuscators/MethodDefinitionObfuscator.ts @@ -42,7 +42,7 @@ export class MethodDefinitionObfuscator extends NodeObfuscator { methodDefinitionNode.computed === false ) { methodDefinitionNode.computed = true; - node.name = this.replaceLiteralStringByUnicodeArrayTranslatorCall(node.name); + node.name = this.replaceLiteralStringByUnicodeArrayCall(node.name); return; } diff --git a/src/node-obfuscators/NodeObfuscator.ts b/src/node-obfuscators/NodeObfuscator.ts index 193edc1d..a0ffc864 100644 --- a/src/node-obfuscators/NodeObfuscator.ts +++ b/src/node-obfuscators/NodeObfuscator.ts @@ -14,10 +14,17 @@ export abstract class NodeObfuscator implements INodeObfuscator { protected nodes: Map ; /** - * @param nodes + * @type any */ - constructor(nodes: Map ) { + protected options: any; + + /** + * @param nodes + * @param options + */ + constructor(nodes: Map , options: any = {}) { this.nodes = nodes; + this.options = options; } /** @@ -70,7 +77,7 @@ export abstract class NodeObfuscator implements INodeObfuscator { * @param nodeValue * @returns {string} */ - protected replaceLiteralStringByUnicodeArrayTranslatorCall (nodeValue: string): string { + protected replaceLiteralStringByUnicodeArrayCall (nodeValue: string): string { let value: string = Utils.stringToUnicode(nodeValue), unicodeArray: string[] = this.nodes.get('unicodeArrayNode').getNodeData(), sameIndex: number = unicodeArray.indexOf(value), @@ -86,6 +93,10 @@ export abstract class NodeObfuscator implements INodeObfuscator { hexadecimalIndex = this.replaceLiteralNumberByHexadecimalValue(index); - return `${this.nodes.get('unicodeArrayTranslator').getNodeIdentifier()}('${hexadecimalIndex}')`; + if (this.options['wrapUnicodeArrayCalls']) { + return `${this.nodes.get('unicodeArrayCallsWrapper').getNodeIdentifier()}('${hexadecimalIndex}')`; + } + + return `${this.nodes.get('unicodeArrayNode').getNodeIdentifier()}[${hexadecimalIndex}]`; } } diff --git a/tests/dev-test.ts b/tests/dev-test.ts index 8203c6b4..4352d5c4 100644 --- a/tests/dev-test.ts +++ b/tests/dev-test.ts @@ -1,6 +1,6 @@ import * as JavaScriptObfuscator from "../index"; -let obfuscatedCode: string = JavaScriptObfuscator.obfuscate( +let obfuscatedCode: string = (JavaScriptObfuscator).obfuscate( ` (function(){ var result = 1,