dev

src/NodeUtils.js

@@ -1,5 +1,23 @@
 "use strict";
 class NodeUtils {
+    static getNodeScope(node, deep = 0) {
+        let scopeNodes = [
+            'FunctionDeclaration',
+            'FunctionExpression',
+            'ArrowFunctionExpression',
+            'MethodDefinition'
+        ];
+        if (node.parentNode.type === 'Program') {
+            return node.parentNode;
+        }
+        if (scopeNodes.indexOf(node.parentNode.type) < 0) {
+            return NodeUtils.getNodeScope(node.parentNode, deep);
+        }
+        if (deep > 0) {
+            return NodeUtils.getNodeScope(node.parentNode, --deep);
+        }
+        return node;
+    }
     static getParentNodeWithType(node, types, limitNodeTypes = [], deep = 0) {
         if (node.parentNode.type === 'Program' || limitNodeTypes.indexOf(node.parentNode.type) >= 0) {
             return node.parentNode;

src/NodeUtils.ts

@@ -1,4 +1,31 @@
 export class NodeUtils {
+    /**
+     * @param node
+     * @param deep
+     */
+    public static getNodeScope (node: any,  deep: number = 0): any {
+        let scopeNodes: string[] = [
+            'FunctionDeclaration',
+            'FunctionExpression',
+            'ArrowFunctionExpression',
+            'MethodDefinition'
+        ];
+
+        if (node.parentNode.type === 'Program') {
+            return node.parentNode;
+        }
+
+        if (scopeNodes.indexOf(node.parentNode.type) < 0) {
+            return NodeUtils.getNodeScope(node.parentNode, deep);
+        }
+
+        if (deep > 0) {
+            return NodeUtils.getNodeScope(node.parentNode, --deep);
+        }
+
+        return node; // BlockStatement of scopeNodes
+    }
+
     /**
      * @param node
      * @param types

src/Obfuscator.js

@@ -3,6 +3,7 @@ const AppendState_1 = require('./enums/AppendState');
 const CatchClauseObfuscator_1 = require("./node-obfuscators/CatchClauseObfuscator");
 const FunctionDeclarationObfuscator_1 = require('./node-obfuscators/FunctionDeclarationObfuscator');
 const FunctionObfuscator_1 = require('./node-obfuscators/FunctionObfuscator');
+const LiteralObfuscator_1 = require('./node-obfuscators/LiteralObfuscator');
 const MemberExpressionObfuscator_1 = require('./node-obfuscators/MemberExpressionObfuscator');
 const MethodDefinitionObfuscator_1 = require('./node-obfuscators/MethodDefinitionObfuscator');
 const ObjectExpressionObfuscator_1 = require('./node-obfuscators/ObjectExpressionObfuscator');
@@ -27,6 +28,7 @@ class Obfuscator {
             ['VariableDeclaration', [VariableDeclarationObfuscator_1.VariableDeclarationObfuscator]],
             ['ObjectExpression', [ObjectExpressionObfuscator_1.ObjectExpressionObfuscator]],
             ['MemberExpression', [MemberExpressionObfuscator_1.MemberExpressionObfuscator]],
+            ['Literal', [LiteralObfuscator_1.LiteralObfuscator]]
         ]);
         this.options = {
             rotateUnicodeArray: true

src/Obfuscator.ts

@@ -14,7 +14,6 @@ import { MethodDefinitionObfuscator } from './node-obfuscators/MethodDefinitionO
 import { ObjectExpressionObfuscator } from './node-obfuscators/ObjectExpressionObfuscator';
 import { UnicodeArrayNode } from './nodes/UnicodeArrayNode';
 import { UnicodeArrayNodesGroup } from './node-groups/UnicodeArrayNodesGroup';
-import { UnicodeArrayRotateFunctionNode } from './nodes/UnicodeArrayRotateFunctionNode';
 import { Utils } from './Utils';
 import { VariableDeclarationObfuscator } from './node-obfuscators/VariableDeclarationObfuscator';
 
@@ -42,7 +41,7 @@ export class Obfuscator {
         ['VariableDeclaration', [VariableDeclarationObfuscator]],
         ['ObjectExpression', [ObjectExpressionObfuscator]],
         ['MemberExpression', [MemberExpressionObfuscator]],
-        //['Literal', [LiteralObfuscator]]
+        ['Literal', [LiteralObfuscator]]
     ]);
 
     /**

src/node-obfuscators/FunctionDeclarationObfuscator.js

@@ -1,5 +1,6 @@
 "use strict";
 const NodeObfuscator_1 = require('./NodeObfuscator');
+const NodeUtils_1 = require("../NodeUtils");
 const Utils_1 = require('../Utils');
 let estraverse = require('estraverse');
 class FunctionDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator {
@@ -12,7 +13,7 @@ class FunctionDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator {
             return;
         }
         this.replaceFunctionName(functionDeclarationNode);
-        this.replaceFunctionCalls(parentNode);
+        this.replaceFunctionCalls(functionDeclarationNode);
     }
     replaceFunctionName(functionDeclarationNode) {
         estraverse.replace(functionDeclarationNode.id, {
@@ -25,9 +26,10 @@ class FunctionDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator {
             }
         });
     }
-    replaceFunctionCalls(functionParentNode) {
-        estraverse.replace(functionParentNode, {
-            leave: (node, parentNode) => {
+    replaceFunctionCalls(functionDeclarationNode) {
+        let scopeNode = NodeUtils_1.NodeUtils.getNodeScope(functionDeclarationNode);
+        estraverse.replace(scopeNode, {
+            enter: (node, parentNode) => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionName);
             }
         });

src/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -1,4 +1,5 @@
 import { NodeObfuscator } from './NodeObfuscator';
+import { NodeUtils } from "../NodeUtils";
 import { Utils } from '../Utils';
 
 let estraverse = require('estraverse');
@@ -28,7 +29,7 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
         }
 
         this.replaceFunctionName(functionDeclarationNode);
-        this.replaceFunctionCalls(parentNode);
+        this.replaceFunctionCalls(functionDeclarationNode);
     }
 
     /**
@@ -48,11 +49,15 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
     }
 
     /**
-     * @param functionParentNode
+     * @param functionDeclarationNode
      */
-    private replaceFunctionCalls (functionParentNode: any): void {
-        estraverse.replace(functionParentNode, {
-            leave: (node, parentNode) => {
+    private replaceFunctionCalls (functionDeclarationNode: any): void {
+        let scopeNode: any = NodeUtils.getNodeScope(
+            functionDeclarationNode
+        );
+
+        estraverse.replace(scopeNode, {
+            enter: (node, parentNode) => {
                 this.replaceNodeIdentifierByNewValue(node, parentNode, this.functionName);
             }
         });

src/node-obfuscators/FunctionObfuscator.js

@@ -14,7 +14,7 @@ class FunctionObfuscator extends NodeObfuscator_1.NodeObfuscator {
     replaceFunctionParams(functionNode) {
         functionNode.params.forEach((paramsNode) => {
             estraverse.replace(paramsNode, {
-                leave: (node, parentNode) => {
+                leave: (node) => {
                     if (node.type !== 'Identifier') {
                         return;
                     }

src/node-obfuscators/FunctionObfuscator.ts

@@ -31,7 +31,7 @@ export class FunctionObfuscator extends NodeObfuscator {
     private replaceFunctionParams (functionNode: any): void {
         functionNode.params.forEach((paramsNode) => {
             estraverse.replace(paramsNode, {
-                leave: (node, parentNode) => {
+                leave: (node) => {
                     if (node.type !== 'Identifier') {
                        return;
                     }

src/node-obfuscators/VariableDeclarationObfuscator.js

@@ -35,7 +35,7 @@ class VariableDeclarationObfuscator extends NodeObfuscator_1.NodeObfuscator {
     replaceVariableCalls(variableDeclarationNode, variableParentNode) {
         let scopeNode, statementNode;
         if (variableDeclarationNode.kind === 'var') {
-            scopeNode = NodeUtils_1.NodeUtils.getParentNodeWithType(variableDeclarationNode, ['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'MethodDefinition']);
+            scopeNode = NodeUtils_1.NodeUtils.getNodeScope(variableDeclarationNode);
         }
         else {
             scopeNode = variableParentNode;

src/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -64,9 +64,8 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
             statementNode: any;
 
         if (variableDeclarationNode.kind === 'var') {
-            scopeNode = NodeUtils.getParentNodeWithType(
-                variableDeclarationNode,
-                ['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'MethodDefinition']
+            scopeNode = NodeUtils.getNodeScope(
+                variableDeclarationNode
             );
         } else {
             scopeNode = variableParentNode;