javascript-obfuscator · sanex3339 · Aug 9, 2018 · Aug 9, 2018 · Aug 9, 2018
diff --git a/CHANGELOG.md b/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/313
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/309
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/307
 

diff --git a/dist/index.browser.js b/dist/index.browser.js
diff --git a/dist/index.cli.js b/dist/index.cli.js
diff --git a/dist/index.js b/dist/index.js
diff --git a/src/node-transformers/obfuscating-transformers/FunctionTransformer.ts b/src/node-transformers/obfuscating-transformers/FunctionTransformer.ts
@@ -123,28 +123,27 @@ export class FunctionTransformer extends AbstractNodeTransformer {
      * @param {TNodeWithLexicalScope} lexicalScopeNode
      */
     private storeFunctionParams (functionNode: ESTree.Function, lexicalScopeNode: TNodeWithLexicalScope): void {
-        functionNode.params
-            .forEach((paramsNode: ESTree.Node) => {
-                estraverse.traverse(paramsNode, {
-                    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;
-                        }
+        const visitor: estraverse.Visitor = {
+            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)) {
-                            this.identifierObfuscatingReplacer.storeLocalName(node.left.name, lexicalScopeNode);
+                if (NodeGuards.isAssignmentPatternNode(node) && NodeGuards.isIdentifierNode(node.left)) {
+                    this.identifierObfuscatingReplacer.storeLocalName(node.left.name, lexicalScopeNode);
 
-                            return estraverse.VisitorOption.Skip;
-                        }
+                    return estraverse.VisitorOption.Skip;
+                }
 
-                        if (NodeGuards.isIdentifierNode(node)) {
-                            this.identifierObfuscatingReplacer.storeLocalName(node.name, lexicalScopeNode);
-                        }
-                    }
-                });
-            });
+                if (NodeGuards.isIdentifierNode(node)) {
+                    this.identifierObfuscatingReplacer.storeLocalName(node.name, lexicalScopeNode);
+                }
+            }
+        };
+
+        functionNode.params.forEach((paramsNode: ESTree.Node) => estraverse.traverse(paramsNode, visitor));
     }
 
     /**
@@ -157,19 +156,12 @@ export class FunctionTransformer extends AbstractNodeTransformer {
         lexicalScopeNode: TNodeWithLexicalScope,
         ignoredIdentifierNamesSet: Set <string> = new Set()
     ): void {
-        const replaceVisitor: estraverse.Visitor = {
+        const visitor: estraverse.Visitor = {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void | estraverse.VisitorOption => {
-                /**
-                 * Should skip function node itself
-                 */
-                if (node === functionNode) {
-                    return;
-                }
-
                 /**
                  * Should process nested functions in different traverse loop to avoid wrong code generation
                  */
-                if (NodeGuards.isFunctionNode(node)) {
+                if (NodeGuards.isFunctionNode(node) && node !== functionNode) {
                     this.replaceFunctionParams(node, lexicalScopeNode, new Set(ignoredIdentifierNamesSet));
 
                     return estraverse.VisitorOption.Skip;
@@ -187,6 +179,7 @@ export class FunctionTransformer extends AbstractNodeTransformer {
                 if (
                     parentNode
                     && NodeGuards.isReplaceableIdentifierNode(node, parentNode)
+                    && !NodeMetadata.isRenamedIdentifier(node)
                     && !ignoredIdentifierNamesSet.has(node.name)
                 ) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
@@ -201,6 +194,6 @@ export class FunctionTransformer extends AbstractNodeTransformer {
             }
         };
 
-        estraverse.replace(functionNode, replaceVisitor)
+        estraverse.replace(functionNode, visitor)
     }
 }
diff --git a/test/dev/dev.ts b/test/dev/dev.ts
@@ -8,16 +8,18 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
         `
         (function(foo){
             function foo () {
-            
+
             }
-
+        
             return new foo();
         })();
+
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
-            transformObjectKeys: true
+            transformObjectKeys: true,
+            seed: 1
         }
     ).getObfuscatedCode();
 

diff --git a/...de-transformers/obfuscating-transformers/function-transformer/FunctionTransformer.spec.ts b/...de-transformers/obfuscating-transformers/function-transformer/FunctionTransformer.spec.ts
@@ -46,59 +46,107 @@ describe('FunctionTransformer', () => {
     });
 
     describe('function id name obfuscation', () => {
-        const functionExpressionParamIdentifierRegExp: RegExp = /\(function *\((_0x[a-f0-9]{4,6})\) *\{/;
-        const functionParamIdentifierRegExp: RegExp = /function *(_0x[a-f0-9]{4,6}) *\(\) *\{/;
-        const functionObjectIdentifierRegExp: RegExp = /return new (_0x[a-f0-9]{4,6}) *\(\);/;
+        describe('Variant #1', () => {
+            const functionExpressionParamIdentifierRegExp: RegExp = /\(function *\((_0x[a-f0-9]{4,6})\) *\{/;
+            const functionParamIdentifierRegExp: RegExp = /function *(_0x[a-f0-9]{4,6}) *\(\) *\{/;
+            const functionObjectIdentifierRegExp: RegExp = /return new (_0x[a-f0-9]{4,6}) *\(\);/;
 
-        let obfuscatedCode: string,
-            functionExpressionParamIdentifierName: string,
-            functionParamIdentifierName: string,
-            functionObjectIdentifierName: string;
+            let obfuscatedCode: string,
+                functionExpressionParamIdentifierName: string,
+                functionParamIdentifierName: string,
+                functionObjectIdentifierName: string;
 
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/function-id-name.js');
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/function-id-name-1.js');
 
-            obfuscatedCode = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET
-                }
-            ).getObfuscatedCode();
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET
+                    }
+                ).getObfuscatedCode();
 
-            const functionExpressionParamIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
-                .match(functionExpressionParamIdentifierRegExp);
-            const functionParamIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
-                .match(functionParamIdentifierRegExp);
-            const functionObjectIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
-                .match(functionObjectIdentifierRegExp);
+                const functionExpressionParamIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
+                    .match(functionExpressionParamIdentifierRegExp);
+                const functionParamIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
+                    .match(functionParamIdentifierRegExp);
+                const functionObjectIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
+                    .match(functionObjectIdentifierRegExp);
 
-            functionParamIdentifierName = (<RegExpMatchArray>functionParamIdentifierMatch)[1];
-            functionExpressionParamIdentifierName = (<RegExpMatchArray>functionExpressionParamIdentifierMatch)[1];
-            functionObjectIdentifierName = (<RegExpMatchArray>functionObjectIdentifierMatch)[1];
-        });
+                functionParamIdentifierName = (<RegExpMatchArray>functionParamIdentifierMatch)[1];
+                functionExpressionParamIdentifierName = (<RegExpMatchArray>functionExpressionParamIdentifierMatch)[1];
+                functionObjectIdentifierName = (<RegExpMatchArray>functionObjectIdentifierMatch)[1];
+            });
 
-        it('should correctly transform function expression parameter identifier', () => {
-            assert.match(obfuscatedCode, functionExpressionParamIdentifierRegExp);
-        });
+            it('should correctly transform function expression parameter identifier', () => {
+                assert.match(obfuscatedCode, functionExpressionParamIdentifierRegExp);
+            });
 
-        it('should correctly transform function parameter identifier', () => {
-            assert.match(obfuscatedCode, functionParamIdentifierRegExp);
-        });
+            it('should correctly transform function parameter identifier', () => {
+                assert.match(obfuscatedCode, functionParamIdentifierRegExp);
+            });
 
-        it('should correctly transform function object parameter identifier', () => {
-            assert.match(obfuscatedCode, functionObjectIdentifierRegExp);
-        });
+            it('should correctly transform function object parameter identifier', () => {
+                assert.match(obfuscatedCode, functionObjectIdentifierRegExp);
+            });
 
-        it('should generate same names for function parameter and function object identifiers', () => {
-            assert.equal(functionParamIdentifierName, functionObjectIdentifierName);
-        });
+            it('should generate same names for function parameter and function object identifiers', () => {
+                assert.equal(functionParamIdentifierName, functionObjectIdentifierName);
+            });
+
+            it('should generate same names for function parameter identifiers', () => {
+                assert.equal(functionExpressionParamIdentifierName, functionParamIdentifierName);
+            });
 
-        it('should generate same names for function parameter identifiers', () => {
-            assert.equal(functionExpressionParamIdentifierName, functionParamIdentifierName);
+            it('should generate same names for function expression parameter and function object identifiers', () => {
+                assert.equal(functionExpressionParamIdentifierName, functionObjectIdentifierName);
+            });
         });
 
-        it('should generate same names for function expression parameter and function object identifiers', () => {
-            assert.equal(functionExpressionParamIdentifierName, functionObjectIdentifierName);
+        describe('Variant #2', () => {
+            const functionIdentifiersRegExp: RegExp = /function *(_0x[a-f0-9]{4,6}) *\((_0x[a-f0-9]{4,6})\) *\{/;
+            const functionObjectIdentifierRegExp: RegExp = /return new (_0x[a-f0-9]{4,6}) *\(\);/;
+
+            let obfuscatedCode: string,
+                functionIdentifierName: string,
+                functionParamIdentifierName: string,
+                functionObjectIdentifierName: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/function-id-name-2.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET
+                    }
+                ).getObfuscatedCode();
+
+                const functionIdentifiersMatch: RegExpMatchArray|null = obfuscatedCode
+                    .match(functionIdentifiersRegExp);
+                const functionObjectIdentifierMatch: RegExpMatchArray|null = obfuscatedCode
+                    .match(functionObjectIdentifierRegExp);
+
+                functionIdentifierName = (<RegExpMatchArray>functionIdentifiersMatch)[1];
+                functionParamIdentifierName = (<RegExpMatchArray>functionIdentifiersMatch)[2];
+                functionObjectIdentifierName = (<RegExpMatchArray>functionObjectIdentifierMatch)[1];
+            });
+
+            it('should correctly transform function identifiers', () => {
+                assert.match(obfuscatedCode, functionIdentifiersRegExp);
+            });
+
+            it('should correctly transform function object parameter identifier', () => {
+                assert.match(obfuscatedCode, functionObjectIdentifierRegExp);
+            });
+
+            it('should generate same names for function parameter and function object identifiers', () => {
+                assert.equal(functionIdentifierName, functionObjectIdentifierName);
+            });
+
+            it('should generate same names for function id and parameter identifiers', () => {
+                assert.equal(functionIdentifierName, functionParamIdentifierName);
+            });
         });
     });
 
@@ -356,27 +404,27 @@ describe('FunctionTransformer', () => {
                 assert.match(obfuscatedCode, functionBodyRegExp);
             });
 
-            it('equal #1: shouldn\'t keep same names for variable declaration identifier and function parameters identifiers', () => {
-                assert.notEqual(variableDeclarationIdentifierName, functionParameterIdentifierName);
+            it('equal #1: should keep same names for variable declaration identifier and function parameters identifiers', () => {
+                assert.equal(variableDeclarationIdentifierName, functionParameterIdentifierName);
             });
 
             it('equal #2: shouldn\'t keep same names for variable declaration identifier and function parameters identifiers', () => {
                 assert.notEqual(variableDeclarationIdentifierName, functionDefaultParameterIdentifierName1);
             });
 
-            it('equal #3: shouldn\'t keep same names for variable declaration identifier and function parameters identifiers', () => {
-                assert.notEqual(variableDeclarationIdentifierName, functionDefaultParameterIdentifierName2);
+            it('equal #3: should keep same names for variable declaration identifier and function parameters identifiers', () => {
+                assert.equal(variableDeclarationIdentifierName, functionDefaultParameterIdentifierName2);
             });
 
-            it('should keep same names for identifier in first function parameter and default value identifier of second function parameter', () => {
+            it('equal #4: should keep same names for identifier in first function parameter and default value identifier of second function parameter', () => {
                 assert.equal(functionParameterIdentifierName, functionDefaultParameterIdentifierName2);
             });
 
-            it('equal #1: should keep same names for identifiers in function params and function body', () => {
+            it('equal #5: should keep same names for identifiers in function params and function body', () => {
                 assert.equal(functionParameterIdentifierName, functionBodyIdentifierName1);
             });
 
-            it('equal #2: should keep same names for identifiers in function params and function body', () => {
+            it('equal #6: should keep same names for identifiers in function params and function body', () => {
                 assert.equal(functionDefaultParameterIdentifierName1, functionBodyIdentifierName2);
             });
         });

diff --git a/...-transformer/fixtures/function-id-name.js → ...ransformer/fixtures/function-id-name-1.js b/...-transformer/fixtures/function-id-name.js → ...ransformer/fixtures/function-id-name-1.js
diff --git a/...transformers/obfuscating-transformers/function-transformer/fixtures/function-id-name-2.js b/...transformers/obfuscating-transformers/function-transformer/fixtures/function-id-name-2.js
@@ -0,0 +1,5 @@
+(function () {
+    function foo (foo) {}
+
+    return new foo();
+})();