Fixed wrong names generation for the custom nodes

sanex3339 · sanex3339 · commit dd7c1df9f900 · 2020-02-15T14:14:59.000+03:00
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/package.json b/package.json
@@ -69,9 +69,9 @@
     "eslint-plugin-jsdoc": "21.0.0",
     "eslint-plugin-no-null": "1.0.2",
     "eslint-plugin-prefer-arrow": "1.1.7",
-    "eslint-plugin-unicorn": "16.1.0",
+    "eslint-plugin-unicorn": "16.1.1",
     "fork-ts-checker-notifier-webpack-plugin": "2.0.0",
-    "fork-ts-checker-webpack-plugin": "4.0.3",
+    "fork-ts-checker-webpack-plugin": "4.0.4",
     "mocha": "7.0.1",
     "nyc": "15.0.0",
     "pjson": "1.0.9",
@@ -81,7 +81,7 @@
     "threads": "1.1.0",
     "ts-loader": "6.2.1",
     "ts-node": "6.1.0",
-    "typescript": "3.8.0-beta",
+    "typescript": "3.8.1-rc",
     "webpack": "4.41.6",
     "webpack-cli": "3.3.11",
     "webpack-node-externals": "1.7.2"
diff --git a/src/custom-nodes/CustomNodeObfuscator.ts b/src/custom-nodes/CustomNodeObfuscator.ts
@@ -7,8 +7,6 @@ import { ICustomNodeObfuscator } from '../interfaces/custom-nodes/ICustomNodeObf
 import { IOptions } from '../interfaces/options/IOptions';
 import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
 
-import { IdentifierNamesGenerator } from '../enums/generators/identifier-names-generators/IdentifierNamesGenerator';
-
 import { NO_ADDITIONAL_NODES_PRESET } from '../options/presets/NoCustomNodes';
 
 import { JavaScriptObfuscator } from '../JavaScriptObfuscatorFacade';
@@ -43,24 +41,8 @@ export class CustomNodeObfuscator implements ICustomNodeObfuscator {
      * @returns {string}
      */
     public obfuscateTemplate (template: string, additionalOptions: TInputOptions = {}): string {
-        /**
-         * During the first pass we should rename all identifiers to a random one
-         */
-        const firstPassObfuscatedCode = JavaScriptObfuscator.obfuscate(
+        return JavaScriptObfuscator.obfuscate(
             template,
-            {
-                ...NO_ADDITIONAL_NODES_PRESET,
-                identifierNamesGenerator: IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator,
-                seed: 1
-            }
-        ).getObfuscatedCode();
-
-        /**
-         * During the seconds pass we should obfuscate template to the same format as the main code
-         * Also, we should add additional transformations that depends on the custom node
-         */
-        const secondPassObfuscatedCode = JavaScriptObfuscator.obfuscate(
-            firstPassObfuscatedCode,
             {
                 ...NO_ADDITIONAL_NODES_PRESET,
                 identifierNamesGenerator: this.options.identifierNamesGenerator,
@@ -69,7 +51,5 @@ export class CustomNodeObfuscator implements ICustomNodeObfuscator {
                 ...additionalOptions
             }
         ).getObfuscatedCode();
-
-        return secondPassObfuscatedCode;
     }
 }
diff --git a/src/custom-nodes/domain-lock-nodes/DomainLockNode.ts b/src/custom-nodes/domain-lock-nodes/DomainLockNode.ts
@@ -90,7 +90,7 @@ export class DomainLockNode extends AbstractCustomNode {
             : GlobalVariableNoEvalTemplate();
 
         return this.customNodeFormatter.formatTemplate(DomainLockNodeTemplate(), {
-            domainLockFunctionName: this.randomGenerator.getRandomString(5),
+            domainLockFunctionName: this.identifierNamesGenerator.generate(),
             diff,
             domains: hiddenDomainsString,
             globalVariableTemplate,
diff --git a/src/custom-nodes/domain-lock-nodes/group/DomainLockCustomNodeGroup.ts b/src/custom-nodes/domain-lock-nodes/group/DomainLockCustomNodeGroup.ts
@@ -91,7 +91,7 @@ export class DomainLockCustomNodeGroup extends AbstractCustomNodeGroup {
             return;
         }
 
-        const callsControllerFunctionName: string = this.randomGenerator.getRandomString(5);
+        const callsControllerFunctionName: string = this.identifierNamesGenerator.generate();
 
         const domainLockNode: ICustomNode<TInitialData<DomainLockNode>> =
             this.customNodeFactory(CustomNode.DomainLockNode);
diff --git a/src/custom-nodes/object-expression-keys-transformer-nodes/ObjectExpressionVariableDeclarationHostNode.ts b/src/custom-nodes/object-expression-keys-transformer-nodes/ObjectExpressionVariableDeclarationHostNode.ts
@@ -14,6 +14,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 
 import { AbstractCustomNode } from '../AbstractCustomNode';
 import { NodeFactory } from '../../node/NodeFactory';
+import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
 export class ObjectExpressionVariableDeclarationHostNode extends AbstractCustomNode {
@@ -60,12 +61,14 @@ export class ObjectExpressionVariableDeclarationHostNode extends AbstractCustomN
      * @returns {TStatement[]}
      */
     protected getNodeStructure (nodeTemplate: string): TStatement[] {
+        const variableDeclarationName: string = NodeGuards.isProgramNode(this.lexicalScopeNode)
+            ? this.identifierNamesGenerator.generate()
+            : this.identifierNamesGenerator.generateForLexicalScope(this.lexicalScopeNode);
+
         const structure: TStatement = NodeFactory.variableDeclarationNode(
             [
                 NodeFactory.variableDeclaratorNode(
-                    NodeFactory.identifierNode(
-                        this.identifierNamesGenerator.generateForLexicalScope(this.lexicalScopeNode)
-                    ),
+                    NodeFactory.identifierNode(variableDeclarationName),
                     NodeFactory.objectExpressionNode(this.properties)
                 )
             ],
diff --git a/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts b/src/custom-nodes/self-defending-nodes/SelfDefendingUnicodeNode.ts
@@ -79,7 +79,7 @@ export class SelfDefendingUnicodeNode extends AbstractCustomNode {
     protected getNodeTemplate (): string {
         return this.customNodeObfuscator.obfuscateTemplate(
             this.customNodeFormatter.formatTemplate(SelfDefendingTemplate(this.escapeSequenceEncoder), {
-                selfDefendingFunctionName: this.randomGenerator.getRandomString(5),
+                selfDefendingFunctionName: this.identifierNamesGenerator.generate(),
                 singleNodeCallControllerFunctionName: this.callsControllerFunctionName
             }),
             {
diff --git a/src/custom-nodes/self-defending-nodes/group/SelfDefendingCustomNodeGroup.ts b/src/custom-nodes/self-defending-nodes/group/SelfDefendingCustomNodeGroup.ts
@@ -91,7 +91,7 @@ export class SelfDefendingCustomNodeGroup extends AbstractCustomNodeGroup {
             return;
         }
 
-        const callsControllerFunctionName: string = this.randomGenerator.getRandomString(5);
+        const callsControllerFunctionName: string = this.identifierNamesGenerator.generate();
 
         const selfDefendingUnicodeNode: ICustomNode<TInitialData<SelfDefendingUnicodeNode>> =
             this.customNodeFactory(CustomNode.SelfDefendingUnicodeNode);
diff --git a/src/interfaces/utils/IRandomGenerator.ts b/src/interfaces/utils/IRandomGenerator.ts
@@ -1,3 +1,5 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
 import type * as Chance from 'chance';
 
 export interface IRandomGenerator {
diff --git a/test/dev/dev.ts b/test/dev/dev.ts
@@ -7,16 +7,19 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            function foo () {
+            const a = '123';
+            const b = '234';
+            const c = '345';
             
-            }
+            console.log(a, b, c);
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
             identifierNamesGenerator: 'mangled',
-            renameGlobals: true,
-            reservedNames: ['a'],
+            selfDefending: true,
+            stringArray: true,
+            stringArrayThreshold: 1,
             log: true
         }
     ).getObfuscatedCode();
diff --git a/test/functional-tests/generators/identifier-names-generators/mangled-identifier-names-generator/MangledIdentifierNamesGenerator.spec.ts b/test/functional-tests/generators/identifier-names-generators/mangled-identifier-names-generator/MangledIdentifierNamesGenerator.spec.ts
@@ -299,5 +299,72 @@ describe('MangledIdentifierNamesGenerator', () => {
                 });
             });
         });
+
+        describe('Variant #3: Should generate different names set for different lexical scopes: nested functions', () => {
+            describe('Variant #1: `renameGlobals` option is disabled', () => {
+                const regExp: RegExp = new RegExp(`` +
+                    `var foo *= *'abc'; *` +
+                    `function bar *\\(a, *b\\) *{` +
+                        `function c *\\(e, *f\\) *{ *} *` +
+                        `function d *\\(e, *f\\) *{ *} *` +
+                    `} *` +
+                    `function baz *\\(a, *b\\) *{` +
+                        `function c *\\(e, *f\\) *{ *} *` +
+                        `function d *\\(e, *f\\) *{ *} *` +
+                    `}` +
+                ``);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/lexical-block-scope-identifiers-2.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('Match #1: should generate valid identifier names', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
+            });
+
+            describe('Variant #2: `renameGlobals` option is enabled', () => {
+                const regExp: RegExp = new RegExp(`` +
+                    `var a *= *'abc'; *` +
+                    `function b *\\(d, *e\\) *{` +
+                        `function f *\\(h, *i\\) *{ *} *` +
+                        `function g *\\(h, *i\\) *{ *} *` +
+                    `} *` +
+                    `function c *\\(d, *e\\) *{` +
+                        `function f *\\(h, *i\\) *{ *} *` +
+                        `function g *\\(h, *i\\) *{ *} *` +
+                    `}` +
+                    ``);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/lexical-block-scope-identifiers-2.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator,
+                            renameGlobals: true
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('Match #1: should generate valid identifier names', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
+            });
+        });
     });
 });
diff --git a/test/functional-tests/generators/identifier-names-generators/mangled-identifier-names-generator/fixtures/lexical-block-scope-identifiers-2.js b/test/functional-tests/generators/identifier-names-generators/mangled-identifier-names-generator/fixtures/lexical-block-scope-identifiers-2.js
@@ -0,0 +1,9 @@
+var foo = 'abc';
+function bar (hawk, bark) {
+    function pig (dog, cat) {}
+    function bird (duck, bear) {}
+}
+function baz (eagle, cow) {
+    function rabbit (mouse, lion) {}
+    function bird (tiger, kiwi) {}
+}
diff --git a/test/functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/VariablePreserveTransformer.spec.ts b/test/functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/VariablePreserveTransformer.spec.ts
@@ -98,8 +98,8 @@ describe('VariablePreserveTransformer', () => {
         });
 
         describe('Variant #2: `renameGlobals` option is enabled', () => {
-            const transformObjectKeysNameRegExp: RegExp = /const b *= *{};/;
-            const identifierNameRegExp: RegExp = /const c *= *b;/;
+            const transformObjectKeysNameRegExp: RegExp = /const c *= *{};/;
+            const identifierNameRegExp: RegExp = /const d *= *c;/;
 
             let obfuscatedCode: string;
 
diff --git a/test/runtime-tests/JavaScriptObfuscatorRuntime.spec.ts b/test/runtime-tests/JavaScriptObfuscatorRuntime.spec.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ export class DomainLockCustomNodeGroup extends AbstractCustomNodeGroup {`
`91`	`91`	`return;`
`92`	`92`	`}`
`93`	`93`
`94`		`- const callsControllerFunctionName: string = this.randomGenerator.getRandomString(5);`
	`94`	`+ const callsControllerFunctionName: string = this.identifierNamesGenerator.generate();`
`95`	`95`
`96`	`96`	`const domainLockNode: ICustomNode<TInitialData<DomainLockNode>> =`
`97`	`97`	`this.customNodeFactory(CustomNode.DomainLockNode);`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ export class SelfDefendingUnicodeNode extends AbstractCustomNode {`
`79`	`79`	`protected getNodeTemplate (): string {`
`80`	`80`	`return this.customNodeObfuscator.obfuscateTemplate(`
`81`	`81`	`this.customNodeFormatter.formatTemplate(SelfDefendingTemplate(this.escapeSequenceEncoder), {`
`82`		`- selfDefendingFunctionName: this.randomGenerator.getRandomString(5),`
	`82`	`+ selfDefendingFunctionName: this.identifierNamesGenerator.generate(),`
`83`	`83`	`singleNodeCallControllerFunctionName: this.callsControllerFunctionName`
`84`	`84`	`}),`
`85`	`85`	`{`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ export class SelfDefendingCustomNodeGroup extends AbstractCustomNodeGroup {`
`91`	`91`	`return;`
`92`	`92`	`}`
`93`	`93`
`94`		`- const callsControllerFunctionName: string = this.randomGenerator.getRandomString(5);`
	`94`	`+ const callsControllerFunctionName: string = this.identifierNamesGenerator.generate();`
`95`	`95`
`96`	`96`	`const selfDefendingUnicodeNode: ICustomNode<TInitialData<SelfDefendingUnicodeNode>> =`
`97`	`97`	`this.customNodeFactory(CustomNode.SelfDefendingUnicodeNode);`