Merge pull request #818 from javascript-obfuscator/issue-813

Ignore object expressions as body of arrow function expression

CHANGELOG.md

@@ -1,5 +1,9 @@
 Change Log
 
+v2.9.2
+---
+* Ignore object expressions as body of arrow function expression when `transformObjectKeys` option is enabled. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/813
+
 v2.9.1
 ---
 * Fixed wrong `stringArrayWrappersParametersMaxCount` CLI option name

dist/index.browser.js.LICENSE.txt

@@ -50,18 +50,3 @@ MERCHANTABLITY OR NON-INFRINGEMENT.
 See the Apache Version 2.0 License for specific language governing permissions
 and limitations under the License.
 ***************************************************************************** */
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "2.9.1",
+  "version": "2.9.2",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -58,13 +58,13 @@
     "@types/mkdirp": "1.0.1",
     "@types/mocha": "8.0.4",
     "@types/multimatch": "4.0.0",
-    "@types/node": "14.14.7",
+    "@types/node": "14.14.8",
     "@types/rimraf": "3.0.0",
     "@types/sinon": "9.0.8",
     "@types/string-template": "1.0.2",
     "@types/webpack-env": "1.15.3",
-    "@typescript-eslint/eslint-plugin": "4.7.0",
-    "@typescript-eslint/parser": "4.7.0",
+    "@typescript-eslint/eslint-plugin": "4.8.1",
+    "@typescript-eslint/parser": "4.8.1",
     "chai": "4.2.0",
     "chai-exclude": "2.0.2",
     "coveralls": "3.1.0",
@@ -76,7 +76,7 @@
     "eslint-plugin-prefer-arrow": "1.2.2",
     "eslint-plugin-unicorn": "23.0.0",
     "fork-ts-checker-notifier-webpack-plugin": "3.0.0",
-    "fork-ts-checker-webpack-plugin": "6.0.1",
+    "fork-ts-checker-webpack-plugin": "6.0.3",
     "mocha": "8.2.1",
     "nyc": "15.1.0",
     "pjson": "1.0.9",
@@ -87,7 +87,7 @@
     "ts-loader": "8.0.11",
     "ts-node": "9.0.0",
     "typescript": "4.1.0-beta",
-    "webpack": "5.4.0",
+    "webpack": "5.5.1",
     "webpack-cli": "4.2.0",
     "webpack-node-externals": "2.5.2"
   },

src/node-transformers/converting-transformers/ObjectExpressionKeysTransformer.ts

@@ -50,39 +50,45 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {ObjectExpression} objectExpressionNode
-     * @param {Statement} hostStatement
+     * @param {Node} objectExpressionParentNode
+     * @param {Statement} objectExpressionHostStatement
      * @returns {boolean}
      */
-    private static isProhibitedHostStatement (
+    private static isProhibitedObjectExpressionNode (
         objectExpressionNode: ESTree.ObjectExpression,
-        hostStatement: ESTree.Statement
+        objectExpressionParentNode: ESTree.Node,
+        objectExpressionHostStatement: ESTree.Statement
     ): boolean {
         return ObjectExpressionKeysTransformer.isReferencedIdentifierName(
                 objectExpressionNode,
-                hostStatement
+                objectExpressionHostStatement
+            )
+            || ObjectExpressionKeysTransformer.isProhibitedArrowFunctionExpression(
+                objectExpressionNode,
+                objectExpressionParentNode
             )
             || ObjectExpressionKeysTransformer.isProhibitedSequenceExpression(
                 objectExpressionNode,
-                hostStatement
+                objectExpressionHostStatement
             );
     }
 
     /**
      * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} hostNode
+     * @param {Node} objectExpressionHostNode
      * @returns {boolean}
      */
     private static isReferencedIdentifierName (
         objectExpressionNode: ESTree.ObjectExpression,
-        hostNode: ESTree.Node,
+        objectExpressionHostNode: ESTree.Node,
     ): boolean {
         const identifierNamesSet: string[] = [];
 
         let isReferencedIdentifierName: boolean = false;
         let isCurrentNode: boolean = false;
 
         // should mark node as prohibited if identifier of node is referenced somewhere inside other nodes
-        estraverse.traverse(hostNode, {
+        estraverse.traverse(objectExpressionHostNode, {
             enter: (node: ESTree.Node): void | estraverse.VisitorOption => {
                 if (node === objectExpressionNode) {
                     isCurrentNode = true;
@@ -116,16 +122,29 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} hostNode
+     * @param {Node} objectExpressionNodeParentNode
+     * @returns {boolean}
+     */
+    private static isProhibitedArrowFunctionExpression (
+        objectExpressionNode: ESTree.ObjectExpression,
+        objectExpressionNodeParentNode: ESTree.Node
+    ): boolean {
+        return NodeGuards.isArrowFunctionExpressionNode(objectExpressionNodeParentNode)
+            && objectExpressionNodeParentNode.body === objectExpressionNode;
+    }
+
+    /**
+     * @param {ObjectExpression} objectExpressionNode
+     * @param {Node} objectExpressionHostNode
      * @returns {boolean}
      */
     private static isProhibitedSequenceExpression (
         objectExpressionNode: ESTree.ObjectExpression,
-        hostNode: ESTree.Node,
+        objectExpressionHostNode: ESTree.Node,
     ): boolean {
-        return NodeGuards.isExpressionStatementNode(hostNode)
-            && NodeGuards.isSequenceExpressionNode(hostNode.expression)
-            && hostNode.expression.expressions.some((expressionNode: ESTree.Expression) =>
+        return NodeGuards.isExpressionStatementNode(objectExpressionHostNode)
+            && NodeGuards.isSequenceExpressionNode(objectExpressionHostNode.expression)
+            && objectExpressionHostNode.expression.expressions.some((expressionNode: ESTree.Expression) =>
                 NodeGuards.isCallExpressionNode(expressionNode)
                 && NodeGuards.isSuperNode(expressionNode.callee)
             );
@@ -182,7 +201,11 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
 
         const hostStatement: ESTree.Statement = NodeStatementUtils.getRootStatementOfNode(objectExpressionNode);
 
-        if (ObjectExpressionKeysTransformer.isProhibitedHostStatement(objectExpressionNode, hostStatement)) {
+        if (ObjectExpressionKeysTransformer.isProhibitedObjectExpressionNode(
+            objectExpressionNode,
+            parentNode,
+            hostStatement
+        )) {
             return objectExpressionNode;
         }
 

test/dev/dev.ts

@@ -1,46 +1,20 @@
 'use strict';
 
 import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNodes';
-import { StringArrayIndexesType } from '../../src/enums/node-transformers/string-array-transformers/StringArrayIndexesType';
 
 (function () {
     const JavaScriptObfuscator: any = require('../../index');
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            // Paste your JavaScript code here
-            function hi() {
-              function inner () {
-                  console.log('inner');
-                  console.log('inner1');
-              }
-              
-              console.log("Hello World!");
-              
-              inner();
-            }
-            hi();
+            const test = () => ({
+                foo: 'bar'
+            });
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
-            rotateStringArray: true,
-            shuffleStringArray: true,
-            stringArray: true,
-            /*stringArrayEncoding: [
-                StringArrayEncoding.None,
-                StringArrayEncoding.Rc4
-            ],*/
-            stringArrayIndexesType: [
-                StringArrayIndexesType.HexadecimalNumericString,
-                StringArrayIndexesType.HexadecimalNumber
-            ],
-            stringArrayIndexShift: true,
-            stringArrayThreshold: 1,
-            stringArrayWrappersCount: 1,
-            stringArrayWrappersChainedCalls: true,
-            stringArrayWrappersParametersMaxCount: 2,
-            stringArrayWrappersType: 'function'
+            transformObjectKeys: true
         }
     ).getObfuscatedCode();
 

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/ObjectExpressionKeysTransformer.spec.ts

@@ -1948,5 +1948,32 @@ describe('ObjectExpressionKeysTransformer', () => {
                 assert.match(obfuscatedCode,  regExp);
             });
         });
+
+        describe('Variant #13: object expression as body of arrow function expression', () => {
+            const match: string = `` +
+                `const test *= *\\(\\) *=> *\\({`+
+                    `'foo' *: *'bar'` +
+                `}\\);` +
+            ``;
+            const regExp: RegExp = new RegExp(match);
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/object-expression-as-body-of-arrow-function-expression.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        transformObjectKeys: true
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('shouldn ignore object expressions keys transformation', () => {
+                assert.match(obfuscatedCode,  regExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/object-expression-as-body-of-arrow-function-expression.js

@@ -0,0 +1,3 @@
+const test = () => ({
+    foo: 'bar'
+});