Identifier replacer refactoring

dist/index.js

@@ -535,11 +535,13 @@ var NodeObfuscator = function () {
         }
     }, {
         key: "replaceIdentifiersWithRandomNames",
-        value: function replaceIdentifiersWithRandomNames(node, namesMap) {
-            if (namesMap.has(node.name)) {
-                return namesMap.get(node.name);
+        value: function replaceIdentifiersWithRandomNames(node, parentNode, namesMap) {
+            var parentNodeIsPropertyNode = Nodes_1.Nodes.isPropertyNode(parentNode) && parentNode.key === node;
+            var parentNodeIsMemberExpressionNode = Nodes_1.Nodes.isMemberExpressionNode(parentNode) && parentNode.computed === false && parentNode.property === node;
+            if (parentNodeIsPropertyNode || parentNodeIsMemberExpressionNode || !namesMap.has(node.name)) {
+                return node.name;
             }
-            return node.name;
+            return namesMap.get(node.name);
         }
     }, {
         key: "replaceLiteralBooleanWithJSFuck",
@@ -2281,9 +2283,9 @@ var CatchClauseObfuscator = function (_NodeObfuscator_1$Nod) {
             var _this3 = this;
 
             estraverse.replace(catchClauseNode, {
-                leave: function leave(node) {
+                leave: function leave(node, parentNode) {
                     if (Nodes_1.Nodes.isIdentifierNode(node)) {
-                        node.name = _this3.replaceIdentifiersWithRandomNames(node, _this3.catchClauseParam);
+                        node.name = _this3.replaceIdentifiersWithRandomNames(node, parentNode, _this3.catchClauseParam);
                     }
                 }
             });
@@ -2361,9 +2363,9 @@ var FunctionDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
 
             var scopeNode = NodeUtils_1.NodeUtils.getBlockScopeOfNode(functionDeclarationNode);
             estraverse.replace(scopeNode, {
-                enter: function enter(node) {
+                enter: function enter(node, parentNode) {
                     if (Nodes_1.Nodes.isIdentifierNode(node)) {
-                        node.name = _this3.replaceIdentifiersWithRandomNames(node, _this3.functionName);
+                        node.name = _this3.replaceIdentifiersWithRandomNames(node, parentNode, _this3.functionName);
                     }
                 }
             });
@@ -2437,9 +2439,9 @@ var FunctionObfuscator = function (_NodeObfuscator_1$Nod) {
             var _this3 = this;
 
             var replaceVisitor = {
-                leave: function leave(node) {
+                leave: function leave(node, parentNode) {
                     if (Nodes_1.Nodes.isIdentifierNode(node)) {
-                        node.name = _this3.replaceIdentifiersWithRandomNames(node, _this3.functionParams);
+                        node.name = _this3.replaceIdentifiersWithRandomNames(node, parentNode, _this3.functionParams);
                     }
                 }
             };
@@ -2822,12 +2824,12 @@ var VariableDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
             var scopeNode = variableDeclarationNode.kind === 'var' ? NodeUtils_1.NodeUtils.getBlockScopeOfNode(variableDeclarationNode) : variableParentNode,
                 isNodeAfterVariableDeclaratorFlag = false;
             estraverse.replace(scopeNode, {
-                enter: function enter(node) {
+                enter: function enter(node, parentNode) {
                     if (Nodes_1.Nodes.isArrowFunctionExpressionNode(node) || Nodes_1.Nodes.isFunctionDeclarationNode(node) || Nodes_1.Nodes.isFunctionExpressionNode(node)) {
                         estraverse.replace(node, {
-                            enter: function enter(node) {
+                            enter: function enter(node, parentNode) {
                                 if (Nodes_1.Nodes.isIdentifierNode(node)) {
-                                    node.name = _this3.replaceIdentifiersWithRandomNames(node, _this3.variableNames);
+                                    node.name = _this3.replaceIdentifiersWithRandomNames(node, parentNode, _this3.variableNames);
                                 }
                             }
                         });
@@ -2836,7 +2838,7 @@ var VariableDeclarationObfuscator = function (_NodeObfuscator_1$Nod) {
                         isNodeAfterVariableDeclaratorFlag = true;
                     }
                     if (Nodes_1.Nodes.isIdentifierNode(node) && isNodeAfterVariableDeclaratorFlag) {
-                        node.name = _this3.replaceIdentifiersWithRandomNames(node, _this3.variableNames);
+                        node.name = _this3.replaceIdentifiersWithRandomNames(node, parentNode, _this3.variableNames);
                     }
                 }
             });

src/node-obfuscators/CatchClauseObfuscator.ts

@@ -42,9 +42,9 @@ export class CatchClauseObfuscator extends NodeObfuscator {
      */
     private replaceCatchClauseParam (catchClauseNode: ICatchClauseNode): void {
         estraverse.replace(catchClauseNode, {
-            leave: (node: INode): any => {
+            leave: (node: INode, parentNode: INode): any => {
                 if (Nodes.isIdentifierNode(node)) {
-                    node.name = this.replaceIdentifiersWithRandomNames(node, this.catchClauseParam);
+                    node.name = this.replaceIdentifiersWithRandomNames(node, parentNode, this.catchClauseParam);
                 }
             }
         });

src/node-obfuscators/FunctionDeclarationObfuscator.ts

@@ -55,9 +55,9 @@ export class FunctionDeclarationObfuscator extends NodeObfuscator {
         );
 
         estraverse.replace(scopeNode, {
-            enter: (node: INode): any => {
+            enter: (node: INode, parentNode: INode): any => {
                 if (Nodes.isIdentifierNode(node)) {
-                    node.name = this.replaceIdentifiersWithRandomNames(node, this.functionName);
+                    node.name = this.replaceIdentifiersWithRandomNames(node, parentNode, this.functionName);
                 }
             }
         });

src/node-obfuscators/FunctionObfuscator.ts

@@ -45,9 +45,9 @@ export class FunctionObfuscator extends NodeObfuscator {
      */
     private replaceFunctionParams (functionNode: IFunctionNode): void {
         let replaceVisitor: estraverse.Visitor = {
-            leave: (node: INode): any => {
+            leave: (node: INode, parentNode: INode): any => {
                 if (Nodes.isIdentifierNode(node)) {
-                    node.name = this.replaceIdentifiersWithRandomNames(node, this.functionParams);
+                    node.name = this.replaceIdentifiersWithRandomNames(node, parentNode, this.functionParams);
                 }
             }
         };

src/node-obfuscators/NodeObfuscator.ts

@@ -68,15 +68,30 @@ export abstract class NodeObfuscator implements INodeObfuscator {
 
     /**
      * @param node
+     * @param parentNode
      * @param namesMap
      * @returns {string}
      */
-    protected replaceIdentifiersWithRandomNames (node: IIdentifierNode, namesMap: Map <string, string>): string {
-        if (namesMap.has(node.name)) {
-            return <string>namesMap.get(node.name);
+    protected replaceIdentifiersWithRandomNames (node: IIdentifierNode, parentNode: INode, namesMap: Map <string, string>): string {
+        const parentNodeIsPropertyNode: boolean = (
+            Nodes.isPropertyNode(parentNode) &&
+            parentNode.key === node
+        );
+        const parentNodeIsMemberExpressionNode: boolean = (
+            Nodes.isMemberExpressionNode(parentNode) &&
+            parentNode.computed === false &&
+            parentNode.property === node
+        );
+
+        if (
+            parentNodeIsPropertyNode ||
+            parentNodeIsMemberExpressionNode ||
+            !namesMap.has(node.name)
+        ) {
+            return node.name;
         }
 
-        return node.name;
+        return <string>namesMap.get(node.name);
     }
 
     /**

src/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -62,16 +62,16 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
             isNodeAfterVariableDeclaratorFlag: boolean = false;
 
         estraverse.replace(scopeNode, {
-            enter: (node: INode): any => {
+            enter: (node: INode, parentNode: INode): any => {
                 if (
                     Nodes.isArrowFunctionExpressionNode(node) ||
                     Nodes.isFunctionDeclarationNode(node) ||
                     Nodes.isFunctionExpressionNode(node)
                 ) {
                     estraverse.replace(node, {
-                        enter: (node: INode): any => {
+                        enter: (node: INode, parentNode: INode): any => {
                             if (Nodes.isIdentifierNode(node)) {
-                                node.name = this.replaceIdentifiersWithRandomNames(node, this.variableNames);
+                                node.name = this.replaceIdentifiersWithRandomNames(node, parentNode, this.variableNames);
                             }
                         }
                     });
@@ -82,7 +82,7 @@ export class VariableDeclarationObfuscator extends NodeObfuscator {
                 }
 
                 if (Nodes.isIdentifierNode(node) && isNodeAfterVariableDeclaratorFlag) {
-                    node.name = this.replaceIdentifiersWithRandomNames(node, this.variableNames);
+                    node.name = this.replaceIdentifiersWithRandomNames(node, parentNode, this.variableNames);
                 }
             }
         });

test/functional-tests/node-obfuscators/VariableDeclarationObfuscator.spec.ts

@@ -85,4 +85,45 @@ describe('VariableDeclarationObfuscator', () => {
             assert.match(obfuscationResult.getObfuscatedCode(),  /console\['\\x6c\\x6f\\x67'\]\(abc\);/);
         });
     });
+
+    describe('wrong replacement', () => {
+        it('shouldn\'t replace property node identifier', () => {
+            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                `
+                function foo () {
+                    var test = 'abc';
+                    
+                    var object = {
+                        test: 'cde'
+                    };
+                    
+                    console.log(test);
+                }
+            `,
+                Object.assign({}, NO_CUSTOM_NODES_PRESET)
+            );
+
+            assert.match(obfuscationResult.getObfuscatedCode(),  /var _0x([a-z0-9]){6} *= *\{'\\x74\\x65\\x73\\x74/);
+        });
+
+        it('shouldn\'t replace computed member expression identifier', () => {
+            let obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                `
+                function foo () {
+                    var test = 'abc';
+                    
+                    var object = {
+                        'test': 'cde'
+                    };
+                    
+                    console.log(test);
+                    console.log(object.test);
+                }
+            `,
+                Object.assign({}, NO_CUSTOM_NODES_PRESET)
+            );
+
+            assert.match(obfuscationResult.getObfuscatedCode(),  /_0x([a-z0-9]){6}\['\\x74\\x65\\x73\\x74'\]/);
+        });
+    });
 });