Merge pull request #218 from javascript-obfuscator/issue-217

Issue 217

CHANGELOG.md

@@ -4,6 +4,7 @@ v0.15.0
 ---
 * **Breaking change:** dropped `node@4` and `node@5` support.
 * **New CLI option:** `exclude` allows to exclude specific files or directories from obfuscation.
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/217
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/210
 
 v0.14.3

package.json

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

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

@@ -146,13 +146,14 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
-                if (parentNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
+                if (parentNode && !node.obfuscatedNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
                         .replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
+                        node.obfuscatedNode = true;
                     } else {
                         storedReplaceableIdentifiers.push(node);
                     }

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

@@ -167,13 +167,14 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
-                if (parentNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
+                if (parentNode && !node.obfuscatedNode && NodeGuards.isReplaceableIdentifierNode(node, parentNode)) {
                     const newIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
                         .replace(node.name, nodeIdentifier);
                     const newIdentifierName: string = newIdentifier.name;
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
+                        node.obfuscatedNode = true;
                     } else {
                         const storedReplaceableIdentifiers: ESTree.Identifier[] = storedReplaceableIdentifiersNamesMap.get(node.name) || [];
 

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

@@ -192,6 +192,7 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
 
                     if (node.name !== newIdentifierName) {
                         node.name = newIdentifierName;
+                        node.obfuscatedNode = true;
                     } else {
                         const storedReplaceableIdentifiers: ESTree.Identifier[] = storedReplaceableIdentifiersNamesMap.get(node.name) || [];
 

test/dev/dev.ts

@@ -6,38 +6,17 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-        (function(){
-            function foo () {
-                var a = 1;
-                inner1();
-                var b = 2;
-                function inner1 () {}
-                var c = 3;
-            }
-            function bar () {
-                var a = 1;
-            }
-            function baz () {
-                var a = 1;
-            }
-            function bark () {
-                var a = 1;
-            }
-            function hawk () {
-                var a = 1;
-            }
-            function eagle () {
-                var a = 1;
+        (function() {
+            function test() {
+                class inner {}
+                let a, b, c, d;
             }
         })();
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
-            stringArray: true,
-            stringArrayThreshold: 1,
-            deadCodeInjection: true,
-            deadCodeInjectionThreshold: 1
+            identifierNamesGenerator: 'mangled'
         }
     ).getObfuscatedCode();
 

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/ClassDeclarationTransformer.spec.ts

@@ -8,6 +8,7 @@ import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
 import { readFileAsString } from '../../../../helpers/readFileAsString';
 
 import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
+import { IdentifierNamesGenerator } from '../../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
 
 describe('ClassDeclarationTransformer', () => {
     describe('transformation of `classDeclaration` node names', () => {
@@ -94,5 +95,33 @@ describe('ClassDeclarationTransformer', () => {
                 });
             });
         });
+
+        describe('Variant #3: already renamed identifiers shouldn\'t be renamed twice', () => {
+            const classDeclarationRegExp: RegExp = /class *d *{/;
+            const variableDeclarationsRegExp: RegExp = /let *e, *f, *g, *h;/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('Match #1: shouldn\'t rename twice class declaration name', () => {
+                assert.match(obfuscatedCode, classDeclarationRegExp);
+            });
+
+            it('Match #2: should correctly rename variable declarations', () => {
+                assert.match(obfuscatedCode, variableDeclarationsRegExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/fixtures/prevent-renaming-of-renamed-identifiers.js

@@ -0,0 +1,6 @@
+(function() {
+    function test() {
+        class inner {}
+        let a, b, c, d;
+    }
+})();

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

@@ -8,6 +8,7 @@ import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
 import { readFileAsString } from '../../../../helpers/readFileAsString';
 
 import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
+import { IdentifierNamesGenerator } from '../../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
 
 describe('FunctionDeclarationTransformer', () => {
     describe('transformation of `functionDeclaration` node names', () => {
@@ -148,5 +149,33 @@ describe('FunctionDeclarationTransformer', () => {
                 assert.equal(functionNameIdentifier, functionCallIdentifier);
             });
         });
+
+        describe('Variant #5: already renamed identifiers shouldn\'t be renamed twice', () => {
+            const functionDeclarationRegExp: RegExp = /function *d\(\) *{/;
+            const variableDeclarationsRegExp: RegExp = /let *e, *f, *g, *h;/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('Match #1: shouldn\'t rename twice function declaration name', () => {
+                assert.match(obfuscatedCode, functionDeclarationRegExp);
+            });
+
+            it('Match #2: should correctly rename variable declarations', () => {
+                assert.match(obfuscatedCode, variableDeclarationsRegExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/obfuscating-transformers/function-declaration-transformer/fixtures/prevent-renaming-of-renamed-identifiers.js

@@ -0,0 +1,6 @@
+(function() {
+    function test() {
+        function inner() {}
+        let a, b, c, d;
+    }
+})();

test/functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/VariableDeclarationTransformer.spec.ts

@@ -7,6 +7,8 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/N
 import { getRegExpMatch } from '../../../../helpers/getRegExpMatch';
 import { readFileAsString } from '../../../../helpers/readFileAsString';
 
+import { IdentifierNamesGenerator } from '../../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
+
 import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
 
 describe('VariableDeclarationTransformer', () => {
@@ -435,4 +437,47 @@ describe('VariableDeclarationTransformer', () => {
             assert.match(obfuscatedCode, regExp);
         });
     });
+
+    describe('Variant #13: already renamed identifiers shouldn\'t be renamed twice', () => {
+        const variableDeclarationRegExp: RegExp = /var *d *= *0x1;/;
+        const functionDeclarationRegExp1: RegExp = /function *e *\(\) *{}/;
+        const functionDeclarationRegExp2: RegExp = /function *f *\(\) *{}/;
+        const functionDeclarationRegExp3: RegExp = /function *g *\(\) *{}/;
+        const functionDeclarationRegExp4: RegExp = /function *h *\(\) *{}/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/prevent-renaming-of-renamed-identifiers.js');
+            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+                }
+            );
+
+            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+        });
+
+        it('Match #1: shouldn\'t rename twice variable declaration name', () => {
+            assert.match(obfuscatedCode, variableDeclarationRegExp);
+        });
+
+        it('Match #2: should correctly rename function declaration name', () => {
+            assert.match(obfuscatedCode, functionDeclarationRegExp1);
+        });
+
+        it('Match #2: should correctly rename function declaration name', () => {
+            assert.match(obfuscatedCode, functionDeclarationRegExp2);
+        });
+
+        it('Match #2: should correctly rename function declaration name', () => {
+            assert.match(obfuscatedCode, functionDeclarationRegExp3);
+        });
+
+        it('Match #2: should correctly rename function declaration name', () => {
+            assert.match(obfuscatedCode, functionDeclarationRegExp4);
+        });
+    });
 });

test/functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/fixtures/prevent-renaming-of-renamed-identifiers.js

@@ -0,0 +1,10 @@
+(function() {
+    function test() {
+        var inner = 1;
+
+        function a () {}
+        function b () {}
+        function c () {}
+        function d () {}
+    }
+})();