Merge pull request #441 from javascript-obfuscator/bug/355_preserve-non-replaceable-variables

Bug #355: Preserve variable names

src/JavaScriptObfuscator.ts

@@ -72,7 +72,8 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.ObjectExpressionTransformer,
         NodeTransformer.ParentificationTransformer,
         NodeTransformer.TemplateLiteralTransformer,
-        NodeTransformer.VariableDeclarationTransformer
+        NodeTransformer.VariableDeclarationTransformer,
+        NodeTransformer.VariablePreserveTransformer
     ];
 
     /**

src/container/modules/node-transformers/PreparingTransformersModule.ts

@@ -16,6 +16,7 @@ import { EvalCallExpressionTransformer } from '../../../node-transformers/prepar
 import { MetadataTransformer } from '../../../node-transformers/preparing-transformers/MetadataTransformer';
 import { ObfuscatingGuardsTransformer } from '../../../node-transformers/preparing-transformers/ObfuscatingGuardsTransformer';
 import { ParentificationTransformer } from '../../../node-transformers/preparing-transformers/ParentificationTransformer';
+import { VariablePreserveTransformer } from "../../../node-transformers/preparing-transformers/VariablePreserveTransformer";
 
 export const preparingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // preparing transformers
@@ -60,4 +61,8 @@ export const preparingTransformersModule: interfaces.ContainerModule = new Conta
             .getCacheFactory<ObfuscatingGuard, IObfuscatingGuard>(
                 ServiceIdentifiers.INodeGuard
             ));
+
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(VariablePreserveTransformer)
+        .whenTargetNamed(NodeTransformer.VariablePreserveTransformer);
 });

src/enums/node-transformers/NodeTransformer.ts

@@ -20,5 +20,6 @@ export enum NodeTransformer {
     ObjectExpressionTransformer = 'ObjectExpressionTransformer',
     ParentificationTransformer = 'ParentificationTransformer',
     TemplateLiteralTransformer = 'TemplateLiteralTransformer',
-    VariableDeclarationTransformer = 'VariableDeclarationTransformer'
+    VariableDeclarationTransformer = 'VariableDeclarationTransformer',
+    VariablePreserveTransformer = 'VariablePreserveTransformer',
 }

src/generators/identifier-names-generators/AbstractIdentifierNamesGenerator.ts

@@ -17,6 +17,11 @@ export abstract class AbstractIdentifierNamesGenerator implements IIdentifierNam
      */
     protected readonly randomGenerator: IRandomGenerator;
 
+    /**
+     * @type {Array}
+     */
+    protected readonly preservedNames: string[] = [];
+
     /**
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
@@ -41,11 +46,27 @@ export abstract class AbstractIdentifierNamesGenerator implements IIdentifierNam
      */
     public abstract generateWithPrefix (nameLength?: number): string;
 
+    /**
+     * @param {string} name
+     * @returns {void}
+     */
+    public preserveName (name: string): void {
+        this.preservedNames.push(name);
+    }
+
     /**
      * @param {string} name
      * @returns {boolean}
      */
     public isValidIdentifierName (name: string): boolean {
+        return this.notReservedName(name) && !this.preservedNames.includes(name);
+    }
+
+    /**
+     * @param {string} name
+     * @returns {boolean}
+     */
+    private notReservedName (name: string): boolean {
         return this.options.reservedNames.length
             ? !this.options.reservedNames.some((reservedName: string) =>
                 new RegExp(reservedName, 'g').exec(name) !== null

src/interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator.d.ts

@@ -16,4 +16,6 @@ export interface IIdentifierNamesGenerator {
      * @returns {boolean}
      */
     isValidIdentifierName (identifierName: string): boolean;
+
+    preserveName (name: string): void;
 }

src/interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer.d.ts

@@ -16,4 +16,6 @@ export interface IIdentifierObfuscatingReplacer extends IObfuscatingReplacer <ES
      * @param {TNodeWithLexicalScope} lexicalScopeNode
      */
     storeLocalName (nodeValue: string, lexicalScopeNode: TNodeWithLexicalScope): void;
+
+    preserveName (name: any): void;
 }

src/node-transformers/obfuscating-transformers/obfuscating-replacers/identifier-obfuscating-replacers/BaseIdentifierObfuscatingReplacer.ts

@@ -102,6 +102,15 @@ export class BaseIdentifierObfuscatingReplacer extends AbstractObfuscatingReplac
         namesMap.set(nodeName, identifierName);
     }
 
+    /**
+     * Preserve `name` to protect it from further using.
+     *
+     * @param {string} name
+     */
+    public preserveName (name: string): void {
+        this.identifierNamesGenerator.preserveName(name);
+    }
+
     /**
      * @param {string} name
      * @returns {boolean}

src/node-transformers/preparing-transformers/VariablePreserveTransformer.ts

@@ -0,0 +1,81 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+import * as ESTree from 'estree';
+import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
+import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { IdentifierObfuscatingReplacer } from "../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer";
+import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeGuards } from '../../node/NodeGuards';
+
+/**
+ * Preserve non-replaceable variables
+ */
+@injectable()
+export class VariablePreserveTransformer extends AbstractNodeTransformer {
+    /**
+     * @type {IIdentifierObfuscatingReplacer}
+     */
+    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
+
+    /**
+     * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    constructor (
+        @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
+            identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+
+        this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
+            IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
+        );
+    }
+
+    /**
+     * @param {TransformationStage} transformationStage
+     * @returns {IVisitor | null}
+     */
+    public getVisitor (transformationStage: TransformationStage): IVisitor | null {
+        switch (transformationStage) {
+            case TransformationStage.Preparing:
+                return {
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
+                        if (parentNode &&
+                            NodeGuards.isIdentifierNode(node) &&
+                            (
+                                NodeGuards.parentNodeIsPropertyNode(node, parentNode) ||
+                                NodeGuards.parentNodeIsMemberExpressionNode(node, parentNode) ||
+                                NodeGuards.parentNodeIsMethodDefinitionNode(node, parentNode) ||
+                                NodeGuards.isLabelIdentifierNode(node, parentNode)
+                            )
+                        ) {
+                            return this.transformNode(node, parentNode);
+                        }
+                    }
+                };
+
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * @param {Identifier} node
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
+     */
+    public transformNode (node: ESTree.Identifier, parentNode: ESTree.Node): ESTree.Node {
+        this.identifierObfuscatingReplacer.preserveName(node.name);
+
+        return node;
+    }
+
+}

src/node/NodeGuards.ts

@@ -299,27 +299,46 @@ export class NodeGuards {
      * @param {Node} parentNode
      * @returns {boolean}
      */
-    public static isReplaceableIdentifierNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
-        if (!NodeGuards.isIdentifierNode(node)) {
-            return false;
-        }
-
-        const parentNodeIsPropertyNode: boolean = NodeGuards.isPropertyNode(parentNode) &&
+    public static parentNodeIsPropertyNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
+        return NodeGuards.isPropertyNode(parentNode) &&
             !parentNode.computed &&
             parentNode.key === node;
-        const parentNodeIsMemberExpressionNode: boolean = (
+    }
+
+    /**
+     * @param {Node} node
+     * @param {Node} parentNode
+     * @returns {boolean}
+     */
+    public static parentNodeIsMemberExpressionNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
+        return (
             NodeGuards.isMemberExpressionNode(parentNode) &&
             !parentNode.computed &&
             parentNode.property === node
         );
-        const parentNodeIsMethodDefinitionNode: boolean = NodeGuards.isMethodDefinitionNode(parentNode) &&
-            !parentNode.computed;
-        const isLabelIdentifierNode: boolean = NodeGuards.isLabelIdentifierNode(node, parentNode);
+    }
 
-        return !parentNodeIsPropertyNode &&
-            !parentNodeIsMemberExpressionNode &&
-            !parentNodeIsMethodDefinitionNode &&
-            !isLabelIdentifierNode;
+    /**
+     * @param {Node} node
+     * @param {Node} parentNode
+     * @returns {boolean}
+     */
+    public static parentNodeIsMethodDefinitionNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
+        return NodeGuards.isMethodDefinitionNode(parentNode) &&
+            !parentNode.computed;
+    }
+
+    /**
+     * @param {Node} node
+     * @param {Node} parentNode
+     * @returns {boolean}
+     */
+    public static isReplaceableIdentifierNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
+        return NodeGuards.isIdentifierNode(node) &&
+            !NodeGuards.parentNodeIsPropertyNode(node, parentNode) &&
+            !NodeGuards.parentNodeIsMemberExpressionNode(node, parentNode) &&
+            !NodeGuards.parentNodeIsMethodDefinitionNode(node, parentNode) &&
+            !NodeGuards.isLabelIdentifierNode(node, parentNode);
     }
 
     /**

test/functional-tests/issues/fixtures/issue355.js

@@ -0,0 +1,3 @@
+function f(obj) {
+    const {c} = obj;
+}

test/functional-tests/issues/issue355.spec.ts

@@ -0,0 +1,32 @@
+import { assert } from 'chai';
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../src/options/presets/NoCustomNodes';
+import { readFileAsString } from '../../helpers/readFileAsString';
+import { JavaScriptObfuscator } from '../../../src/JavaScriptObfuscatorFacade';
+import { IdentifierNamesGenerator } from "../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator";
+
+//
+// https://github.com/javascript-obfuscator/javascript-obfuscator/issues/355
+//
+describe('Issue #355', () => {
+    describe('Fixture code should nor break', () => {
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/issue355.js');
+
+            obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    stringArray: false,
+                    identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator
+                }
+            ).getObfuscatedCode();
+
+        });
+
+        it('does not break on run', () => {
+            assert.doesNotThrow(() => eval(obfuscatedCode));
+        });
+    });
+});