Code transformers #2: HashbangOperatorTransformer

src/JavaScriptObfuscator.ts

@@ -7,6 +7,7 @@ import * as ESTree from 'estree';
 
 import { TObfuscatedCodeFactory } from './types/container/source-code/TObfuscatedCodeFactory';
 
+import { ICodeTransformersRunner } from './interfaces/code-transformers/ICodeTransformersRunner';
 import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
 import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
 import { ILogger } from './interfaces/logger/ILogger';
@@ -15,6 +16,8 @@ import { IOptions } from './interfaces/options/IOptions';
 import { IRandomGenerator } from './interfaces/utils/IRandomGenerator';
 import { INodeTransformersRunner } from './interfaces/node-transformers/INodeTransformersRunner';
 
+import { CodeTransformer } from './enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from './enums/code-transformers/CodeTransformationStage';
 import { LoggingMessage } from './enums/logger/LoggingMessage';
 import { NodeTransformer } from './enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from './enums/node-transformers/NodeTransformationStage';
@@ -48,10 +51,17 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         sourceMapWithCode: true
     };
 
+    /**
+     * @type {CodeTransformer[]}
+     */
+    private static readonly codeTransformersList: CodeTransformer[] = [
+        CodeTransformer.HashbangOperatorTransformer
+    ];
+
     /**
      * @type {NodeTransformer[]}
      */
-    private static readonly transformersList: NodeTransformer[] = [
+    private static readonly nodeTransformersList: NodeTransformer[] = [
         NodeTransformer.BlockStatementControlFlowTransformer,
         NodeTransformer.CommentsTransformer,
         NodeTransformer.CustomCodeHelpersTransformer,
@@ -73,6 +83,11 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.VariablePreserveTransformer
     ];
 
+    /**
+     * @type {ICodeTransformersRunner}
+     */
+    private readonly codeTransformersRunner: ICodeTransformersRunner;
+
     /**
      * @type {ILogger}
      */
@@ -96,23 +111,26 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
     /**
      * @type {INodeTransformersRunner}
      */
-    private readonly transformersRunner: INodeTransformersRunner;
+    private readonly nodeTransformersRunner: INodeTransformersRunner;
 
     /**
-     * @param {INodeTransformersRunner} transformersRunner
+     * @param {ICodeTransformersRunner} codeTransformersRunner
+     * @param {INodeTransformersRunner} nodeTransformersRunner
      * @param {IRandomGenerator} randomGenerator
      * @param {TObfuscatedCodeFactory} obfuscatedCodeFactory
      * @param {ILogger} logger
      * @param {IOptions} options
      */
     public constructor (
-        @inject(ServiceIdentifiers.INodeTransformersRunner) transformersRunner: INodeTransformersRunner,
+        @inject(ServiceIdentifiers.ICodeTransformersRunner) codeTransformersRunner: ICodeTransformersRunner,
+        @inject(ServiceIdentifiers.INodeTransformersRunner) nodeTransformersRunner: INodeTransformersRunner,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.Factory__IObfuscatedCode) obfuscatedCodeFactory: TObfuscatedCodeFactory,
         @inject(ServiceIdentifiers.ILogger) logger: ILogger,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
-        this.transformersRunner = transformersRunner;
+        this.codeTransformersRunner = codeTransformersRunner;
+        this.nodeTransformersRunner = nodeTransformersRunner;
         this.randomGenerator = randomGenerator;
         this.obfuscatedCodeFactory = obfuscatedCodeFactory;
         this.logger = logger;
@@ -129,6 +147,9 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         this.logger.info(LoggingMessage.ObfuscationStarted);
         this.logger.info(LoggingMessage.RandomGeneratorSeed, this.randomGenerator.getInputSeed());
 
+        // preparing code transformations
+        sourceCode = this.runCodeTransformationStage(sourceCode, CodeTransformationStage.PreparingTransformers);
+
         // parse AST tree
         const astTree: ESTree.Program = this.parseCode(sourceCode);
 
@@ -138,6 +159,9 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         // generate code
         const generatorOutput: IGeneratorOutput = this.generateCode(sourceCode, obfuscatedAstTree);
 
+        // finalizing code transformations
+        generatorOutput.code = this.runCodeTransformationStage(generatorOutput.code, CodeTransformationStage.FinalizingTransformers);
+
         const obfuscationTime: number = (Date.now() - timeStart) / 1000;
         this.logger.success(LoggingMessage.ObfuscationCompleted, obfuscationTime);
 
@@ -157,7 +181,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @returns {Program}
      */
     private transformAstTree (astTree: ESTree.Program): ESTree.Program {
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Initializing);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Initializing);
 
         const isEmptyAstTree: boolean = NodeGuards.isProgramNode(astTree)
             && !astTree.body.length
@@ -170,19 +194,19 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
             return astTree;
         }
 
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Preparing);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Preparing);
 
         if (this.options.deadCodeInjection) {
-            astTree = this.runTransformationStage(astTree, NodeTransformationStage.DeadCodeInjection);
+            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.DeadCodeInjection);
         }
 
         if (this.options.controlFlowFlattening) {
-            astTree = this.runTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
+            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
         }
 
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Converting);
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Obfuscating);
-        astTree = this.runTransformationStage(astTree, NodeTransformationStage.Finalizing);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Obfuscating);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Finalizing);
 
         return astTree;
     }
@@ -222,17 +246,32 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         return this.obfuscatedCodeFactory(generatorOutput.code, generatorOutput.map);
     }
 
+    /**
+     * @param {string} code
+     * @param {CodeTransformationStage} codeTransformationStage
+     * @returns {string}
+     */
+    private runCodeTransformationStage (code: string, codeTransformationStage: CodeTransformationStage): string {
+        this.logger.info(LoggingMessage.CodeTransformationStage, codeTransformationStage);
+
+        return this.codeTransformersRunner.transform(
+            code,
+            JavaScriptObfuscator.codeTransformersList,
+            codeTransformationStage
+        );
+    }
+
     /**
      * @param {Program} astTree
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {Program}
      */
-    private runTransformationStage (astTree: ESTree.Program, nodeTransformationStage: NodeTransformationStage): ESTree.Program {
-        this.logger.info(LoggingMessage.TransformationStage, nodeTransformationStage);
+    private runNodeTransformationStage (astTree: ESTree.Program, nodeTransformationStage: NodeTransformationStage): ESTree.Program {
+        this.logger.info(LoggingMessage.NodeTransformationStage, nodeTransformationStage);
 
-        return this.transformersRunner.transform(
+        return this.nodeTransformersRunner.transform(
             astTree,
-            JavaScriptObfuscator.transformersList,
+            JavaScriptObfuscator.nodeTransformersList,
             nodeTransformationStage
         );
     }