Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/293

CHANGELOG.md

@@ -2,6 +2,7 @@ Change Log
 ===
 v0.18.0
 ---
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/293
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/289
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/288
 

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

@@ -6,6 +6,8 @@ import * as ESTree from 'estree';
 
 import { TIdentifierObfuscatingReplacerFactory } from "../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory";
 import { TNodeWithBlockScope } from '../../types/node/TNodeWithBlockScope';
+import { TReplaceableIdentifiers } from '../../types/node-transformers/TReplaceableIdentifiers';
+import { TReplaceableIdentifiersNames } from '../../types/node-transformers/TReplaceableIdentifiersNames';
 
 import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -40,7 +42,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     /**
      * @type {Map<ESTree.Node, ESTree.Identifier[]>}
      */
-    private readonly replaceableIdentifiers: Map <ESTree.Node, ESTree.Identifier[]> = new Map();
+    private readonly replaceableIdentifiers: TReplaceableIdentifiers = new Map();
 
     /**
      * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
@@ -101,7 +103,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
 
         // check for cached identifiers for current scope node. If exist - loop through them.
         if (this.replaceableIdentifiers.has(blockScopeNode)) {
-            this.replaceScopeCachedIdentifiers(blockScopeNode);
+            this.replaceScopeCachedIdentifiers(classDeclarationNode, blockScopeNode);
         } else {
             this.replaceScopeIdentifiers(blockScopeNode);
         }
@@ -127,26 +129,44 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
+     * @param {ClassDeclaration} classDeclarationNode
      * @param {TNodeWithBlockScope} blockScopeNode
      */
-    private replaceScopeCachedIdentifiers (blockScopeNode: TNodeWithBlockScope): void {
-        const cachedReplaceableIdentifiers: ESTree.Identifier[] =
-            <ESTree.Identifier[]>this.replaceableIdentifiers.get(blockScopeNode);
+    private replaceScopeCachedIdentifiers (
+        classDeclarationNode: ESTree.ClassDeclaration,
+        blockScopeNode: TNodeWithBlockScope
+    ): void {
+        const cachedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames | undefined =
+            this.replaceableIdentifiers.get(blockScopeNode);
+
+        if (!cachedReplaceableIdentifiersNamesMap) {
+            return;
+        }
+
+        const cachedReplaceableIdentifiers: ESTree.Identifier[] | undefined = cachedReplaceableIdentifiersNamesMap
+            .get(classDeclarationNode.id.name);
 
-        cachedReplaceableIdentifiers.forEach((replaceableIdentifier: ESTree.Identifier) => {
+        if (!cachedReplaceableIdentifiers) {
+            return;
+        }
+
+        const cachedReplaceableIdentifierLength: number = cachedReplaceableIdentifiers.length;
+
+        for (let i: number = 0; i < cachedReplaceableIdentifierLength; i++) {
+            const replaceableIdentifier: ESTree.Identifier = cachedReplaceableIdentifiers[i];
             const newReplaceableIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
                 .replace(replaceableIdentifier.name, blockScopeNode);
 
             replaceableIdentifier.name = newReplaceableIdentifier.name;
             NodeMetadata.set(replaceableIdentifier, { renamedIdentifier: true });
-        });
+        }
     }
 
     /**
      * @param {TNodeWithBlockScope} blockScopeNode
      */
     private replaceScopeIdentifiers (blockScopeNode: TNodeWithBlockScope): void {
-        const storedReplaceableIdentifiers: ESTree.Identifier[] = [];
+        const storedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames = new Map();
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
@@ -163,12 +183,16 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
                         node.name = newIdentifierName;
                         NodeMetadata.set(node, { renamedIdentifier: true });
                     } else {
+                        const storedReplaceableIdentifiers: ESTree.Identifier[] =
+                            storedReplaceableIdentifiersNamesMap.get(node.name) || [];
+
                         storedReplaceableIdentifiers.push(node);
+                        storedReplaceableIdentifiersNamesMap.set(node.name, storedReplaceableIdentifiers);
                     }
                 }
             }
         });
 
-        this.replaceableIdentifiers.set(blockScopeNode, storedReplaceableIdentifiers);
+        this.replaceableIdentifiers.set(blockScopeNode, storedReplaceableIdentifiersNamesMap);
     }
 }

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

@@ -68,30 +68,60 @@ describe('ClassDeclarationTransformer', () => {
             });
 
             describe('Variant #2: `renameGlobals` option is enabled', () => {
-                const classNameIdentifierRegExp: RegExp = /class *(_0x[a-f0-9]{4,6}) *\{/;
-                const classCallIdentifierRegExp: RegExp = /new *(_0x[a-f0-9]{4,6}) *\( *\);/;
+                describe('Variant #1: Base', () => {
+                    const classNameIdentifierRegExp: RegExp = /class *(_0x[a-f0-9]{4,6}) *\{/;
+                    const classCallIdentifierRegExp: RegExp = /new *(_0x[a-f0-9]{4,6}) *\( *\);/;
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
+                        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                renameGlobals: true
+                            }
+                        );
+
+                        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    });
+
+                    it('match #1: should transform class name', () => {
+                        assert.match(obfuscatedCode, classNameIdentifierRegExp);
+                    });
+
+                    it('match #2: should transform class name', () => {
+                        assert.match(obfuscatedCode, classCallIdentifierRegExp);
+                    });
+                });
 
-                let obfuscatedCode: string;
+                describe('Variant #2: Two classes. Transformation of identifier inside class method', () => {
+                    const identifierRegExp1: RegExp = /const (?:_0x[a-f0-9]{4,6}) *= *0x1;/;
+                    const identifierRegExp2: RegExp = /const (?:_0x[a-f0-9]{4,6}) *= *0x2;/;
 
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            renameGlobals: true
-                        }
-                    );
+                    let obfuscatedCode: string;
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                });
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/rename-globals-identifier-transformation.js');
+                        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                renameGlobals: true
+                            }
+                        );
 
-                it('match #1: should transform class name', () => {
-                    assert.match(obfuscatedCode, classNameIdentifierRegExp);
-                });
+                        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    });
 
-                it('match #2: should transform class name', () => {
-                    assert.match(obfuscatedCode, classCallIdentifierRegExp);
+                    it('match #1: should transform identifier name inside class method', () => {
+                        assert.match(obfuscatedCode, identifierRegExp1);
+                    });
+
+                    it('match #2: should transform identifier name inside class method', () => {
+                        assert.match(obfuscatedCode, identifierRegExp2);
+                    });
                 });
             });
         });

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/fixtures/rename-globals-identifier-transformation.js

@@ -0,0 +1,11 @@
+class Foo {
+    foo() {
+        const foo = 1;
+    }
+}
+
+class Bar {
+    bar() {
+        const bar = 2;
+    }
+}