Merge pull request #310 from javascript-obfuscator/function-obfuscation-bugs

Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/…

CHANGELOG.md

@@ -3,6 +3,7 @@ Change Log
 v0.18.0
 ---
 * **New option:** `reservedStrings` disables transformation of string literals, which being matched by passed RegExp patterns
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/307
 
 v0.17.3
 ---

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.18.0-dev.2",
+  "version": "0.18.0-dev.3",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",

src/node-transformers/obfuscating-transformers/FunctionTransformer.ts

@@ -55,9 +55,26 @@ export class FunctionTransformer extends AbstractNodeTransformer {
 
     /**
      * @param {Node} node
+     * @param {Node} parentNode
      * @returns {boolean}
      */
-    private static isProhibitedPropertyNode (node: ESTree.Node): node is ESTree.Property & {key: ESTree.Identifier} {
+    private static isProhibitedIdentifierOfPropertyNode (
+        node: ESTree.Node,
+        parentNode: ESTree.Node | null
+    ): node is ESTree.Identifier {
+        return NodeGuards.isIdentifierNode(node)
+            && !!parentNode
+            && NodeGuards.isPropertyNode(parentNode)
+            && parentNode.key === node;
+    }
+
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    private static isProhibitedIdentifierOfShorthandPropertyNode (
+        node: ESTree.Node,
+    ): node is ESTree.Property & {key: ESTree.Identifier} {
         return NodeGuards.isPropertyNode(node)
             && node.shorthand
             && NodeGuards.isIdentifierNode(node.key);
@@ -109,9 +126,11 @@ export class FunctionTransformer extends AbstractNodeTransformer {
         functionNode.params
             .forEach((paramsNode: ESTree.Node) => {
                 estraverse.traverse(paramsNode, {
-                    enter: (node: ESTree.Node): estraverse.VisitorOption | void => {
-                        if (FunctionTransformer.isProhibitedPropertyNode(node)) {
-                            return estraverse.VisitorOption.Skip;
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): estraverse.VisitorOption | void => {
+                        // Should check with identifier as first argument,
+                        // because prohibited identifier can be easily ignored
+                        if (FunctionTransformer.isProhibitedIdentifierOfPropertyNode(node, parentNode)) {
+                            return;
                         }
 
                         if (NodeGuards.isAssignmentPatternNode(node) && NodeGuards.isIdentifierNode(node.left)) {
@@ -150,10 +169,12 @@ export class FunctionTransformer extends AbstractNodeTransformer {
                 }
 
                 /**
-                 * Should to ignore all identifiers that related to shorthand properties
+                 * Should ignore all shorthand `key` identifiers of the `PropertyNode`
                  */
-                if (FunctionTransformer.isProhibitedPropertyNode(node)) {
+                if (FunctionTransformer.isProhibitedIdentifierOfShorthandPropertyNode(node)) {
                     ignoredIdentifierNamesSet.add(node.key.name);
+
+                    return;
                 }
 
                 if (

test/dev/dev.ts

@@ -6,8 +6,13 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-        const foo = 1;
-        [].map(foo=>1).map(bar=>[foo]);
+        (function(){
+            function foo ({id}) {
+                function bar ({id: baz}) {
+                    return id !== baz;
+                }
+            }
+        })();
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,

test/functional-tests/node-transformers/obfuscating-transformers/function-transformer/FunctionTransformer.spec.ts

@@ -143,6 +143,42 @@ describe('FunctionTransformer', () => {
                 assert.match(obfuscatedCode, returnRegExp2);
             });
         });
+
+        describe('Variant #4: shorthand property node', () => {
+            const functionObjectPatternParameterRegExp1: RegExp = /function _0x[a-f0-9]{4,6} *\({id}\) *{/;
+            const functionObjectPatternParameterRegExp2: RegExp = /function _0x[a-f0-9]{4,6} *\({id: *_0x[a-f0-9]{4,6}}\) *{/;
+            const consoleLogRegExp: RegExp = /console\['log']\(id\);/;
+            const returnRegExp: RegExp = /return id *\+ *_0x[a-f0-9]{4,6};/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/object-pattern-as-parameter-4.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('match #1: should transform function parameter object pattern rest identifier', () => {
+                assert.match(obfuscatedCode, functionObjectPatternParameterRegExp1);
+            });
+
+            it('match #2: should transform function parameter object pattern rest identifier', () => {
+                assert.match(obfuscatedCode, functionObjectPatternParameterRegExp2);
+            });
+
+            it('match #3: should transform identifier in `console.log` of outer function', () => {
+                assert.match(obfuscatedCode, consoleLogRegExp);
+            });
+
+            it('match #4: should transform identifier in `ReturnStatement` of inner function', () => {
+                assert.match(obfuscatedCode, returnRegExp);
+            });
+        });
     });
 
     describe('assignment pattern as parameter', () => {

test/functional-tests/node-transformers/obfuscating-transformers/function-transformer/fixtures/object-pattern-as-parameter-4.js

@@ -0,0 +1,9 @@
+(function(){
+    function foo ({id}) {
+        console.log(id);
+
+        function bar ({id: baz}) {
+            return id +baz;
+        }
+    }
+})();