IfStatementDeadCodeInjectionReplacer

src/container/InversifyContainerFacade.ts

@@ -3,6 +3,7 @@ import { ServiceIdentifiers } from './ServiceIdentifiers';
 
 import { controlFlowTransformersModule } from './modules/node-transformers/ControlFlowTransformersModule';
 import { customNodesModule } from './modules/custom-nodes/CustomNodesModule';
+import { deadCodeInjectionTransformersModule } from './modules/node-transformers/DeadCodeInjectionTransformersModule';
 import { obfuscatingTransformersModule } from './modules/node-transformers/ObfuscatingTransformersModule';
 import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
 import { stackTraceAnalyzerModule } from './modules/stack-trace-analyzer/StackTraceAnalyzerModule';
@@ -88,6 +89,7 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         this.container.load(customNodesModule);
         this.container.load(nodeTransformersModule);
         this.container.load(controlFlowTransformersModule);
+        this.container.load(deadCodeInjectionTransformersModule);
         this.container.load(obfuscatingTransformersModule);
     }
 

src/container/ServiceIdentifiers.ts

@@ -3,6 +3,7 @@ export const ServiceIdentifiers: any = {
     Factory__IControlFlowReplacer: Symbol('Factory<IControlFlowReplacer>'),
     Factory__ICustomNode: Symbol('Factory<ICustomNode>'),
     Factory__ICustomNodeGroup: Symbol('Factory<ICustomNodeGroup>'),
+    Factory__IDeadCodeInjectionReplacer: Symbol('Factory<IDeadCodeInjectionReplacer>'),
     Factory__INodeTransformer: Symbol('Factory<INodeTransformer[]>'),
     Factory__IObfuscationResult: Symbol('Factory<IObfuscationResult>'),
     Factory__IObfuscationReplacer: Symbol('Factory<IObfuscationReplacer>'),
@@ -10,6 +11,7 @@ export const ServiceIdentifiers: any = {
     ICalleeDataExtractor: Symbol('ICalleeDataExtractor'),
     ICustomNodeGroup: Symbol('ICustomNodeGroup'),
     IControlFlowReplacer: Symbol('IControlFlowReplacer'),
+    IDeadCodeInjectionReplacer: Symbol('IDeadCodeInjectionReplacer'),
     IJavaScriptObfuscator: Symbol('IJavaScriptObfuscator'),
     INodeTransformer: Symbol('INodeTransformer'),
     IObfuscationEventEmitter: Symbol('IObfuscationEventEmitter'),

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

@@ -0,0 +1,33 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IDeadCodeInjectionReplacer } from '../../../interfaces/node-transformers/IDeadCodeInjectionReplacer';
+import { IfStatementDeadCodeInjectionReplacer } from '../../../node-transformers/dead-code-injection-transformers/dead-code-injection-replacers/IfStatementDeadCodeInjectionReplacer';
+
+import { DeadCodeInjectionReplacers } from '../../../enums/container/DeadCodeInjectionReplacers';
+
+export const deadCodeInjectionTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    bind<IDeadCodeInjectionReplacer>(ServiceIdentifiers.IDeadCodeInjectionReplacer)
+        .to(IfStatementDeadCodeInjectionReplacer)
+        .whenTargetNamed(DeadCodeInjectionReplacers.IfStatementDeadCodeInjectionReplacer);
+
+    bind<IDeadCodeInjectionReplacer>(ServiceIdentifiers.Factory__IDeadCodeInjectionReplacer)
+        .toFactory<IDeadCodeInjectionReplacer>((context: interfaces.Context) => {
+            const cache: Map <DeadCodeInjectionReplacers, IDeadCodeInjectionReplacer> = new Map();
+
+            return (replacerName: DeadCodeInjectionReplacers) => {
+                if (cache.has(replacerName)) {
+                    return <IDeadCodeInjectionReplacer>cache.get(replacerName);
+                }
+
+                const deadCodeInjectionReplacer: IDeadCodeInjectionReplacer = context.container.getNamed<IDeadCodeInjectionReplacer>(
+                    ServiceIdentifiers.IDeadCodeInjectionReplacer,
+                    replacerName
+                );
+
+                cache.set(replacerName, deadCodeInjectionReplacer);
+
+                return deadCodeInjectionReplacer;
+            };
+        });
+});

src/enums/container/DeadCodeInjectionReplacers.ts

@@ -0,0 +1,3 @@
+export enum DeadCodeInjectionReplacers {
+    IfStatementDeadCodeInjectionReplacer
+}

src/interfaces/node-transformers/IDeadCodeInjectionReplacer.d.ts

@@ -0,0 +1,13 @@
+import * as ESTree from 'estree';
+
+export interface IDeadCodeInjectionReplacer {
+    /**
+     * @param node
+     * @param parentNode
+     * @returns ESTree.Node
+     */
+    replace (
+        node: ESTree.Node,
+        parentNode: ESTree.Node
+    ): ESTree.Node;
+}

src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.ts

@@ -221,6 +221,10 @@ export class FunctionControlFlowTransformer extends AbstractNodeTransformer {
                 const controlFlowReplacerName: ControlFlowReplacers = <ControlFlowReplacers>FunctionControlFlowTransformer
                     .controlFlowReplacersMap.get(node.type);
 
+                if (controlFlowReplacerName === undefined) {
+                    return node;
+                }
+
                 return {
                     ...this.controlFlowReplacerFactory(controlFlowReplacerName).replace(node, parentNode, controlFlowStorage),
                     parentNode

src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.ts

@@ -1,11 +1,16 @@
 import { injectable, inject } from 'inversify';
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
+import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { TDeadCodeInjectionReplacerFactory } from '../../types/container/TDeadCodeInjectionReplacerFactory';
+
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IVisitor } from '../../interfaces/IVisitor';
 
+import { DeadCodeInjectionReplacers } from '../../enums/container/DeadCodeInjectionReplacers';
+
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { Node } from '../../node/Node';
 import { RandomGeneratorUtils } from '../../utils/RandomGeneratorUtils';
@@ -13,12 +18,28 @@ import { RandomGeneratorUtils } from '../../utils/RandomGeneratorUtils';
 @injectable()
 export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
     /**
+     * @type {DeadCodeInjectionReplacers[]}
+     */
+    private static readonly deadCodeInjectionReplacersList: DeadCodeInjectionReplacers[] = [
+        DeadCodeInjectionReplacers.IfStatementDeadCodeInjectionReplacer
+    ];
+
+    /**
+     * @type {TDeadCodeInjectionReplacerFactory}
+     */
+    private deadCodeInjectionReplacerFactory: TDeadCodeInjectionReplacerFactory;
+
+    /**
+     * @param deadCodeInjectionReplacerFactory
      * @param options
      */
     constructor (
+        @inject(ServiceIdentifiers.Factory__IDeadCodeInjectionReplacer) deadCodeInjectionReplacerFactory: TDeadCodeInjectionReplacerFactory,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(options);
+
+        this.deadCodeInjectionReplacerFactory = deadCodeInjectionReplacerFactory;
     }
 
     /**
@@ -47,6 +68,28 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
             return blockStatementNode;
         }
 
+        this.transformBlockStatementNode(blockStatementNode);
+
         return blockStatementNode;
     }
+
+    /**
+     * @param blockStatementNode
+     */
+    private transformBlockStatementNode (blockStatementNode: ESTree.BlockStatement): void {
+        estraverse.replace(blockStatementNode, {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
+                let newNode: ESTree.Node = node;
+
+                DeadCodeInjectionTransformer.deadCodeInjectionReplacersList.forEach((replacerName: DeadCodeInjectionReplacers) => {
+                    newNode = {
+                        ...this.deadCodeInjectionReplacerFactory(replacerName).replace(node, parentNode),
+                        parentNode
+                    };
+                });
+
+                return newNode;
+            }
+        });
+    }
 }

src/node-transformers/dead-code-injection-transformers/dead-code-injection-replacers/AbstractDeadCodeInjectionReplacer.ts

@@ -0,0 +1,41 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { TCustomNodeFactory } from '../../../types/container/TCustomNodeFactory';
+
+import { IDeadCodeInjectionReplacer } from '../../../interfaces/node-transformers/IDeadCodeInjectionReplacer';
+import { IOptions } from '../../../interfaces/options/IOptions';
+
+@injectable()
+export abstract class AbstractDeadCodeInjectionReplacer implements IDeadCodeInjectionReplacer {
+    /**
+     * @type {TCustomNodeFactory}
+     */
+    protected readonly customNodeFactory: TCustomNodeFactory;
+
+    /**
+     * @type {IOptions}
+     */
+    protected readonly options: IOptions;
+
+    /**
+     * @param customNodeFactory
+     * @param options
+     */
+    constructor (
+        @inject(ServiceIdentifiers.Factory__ICustomNode) customNodeFactory: TCustomNodeFactory,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        this.customNodeFactory = customNodeFactory;
+        this.options = options;
+    }
+
+    /**
+     * @param node
+     * @param parentNode
+     * @returns {ESTree.Node}
+     */
+    public abstract replace (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node;
+}

src/node-transformers/dead-code-injection-transformers/dead-code-injection-replacers/IfStatementDeadCodeInjectionReplacer.ts

@@ -0,0 +1,33 @@
+import { injectable, inject } from 'inversify';
+import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { TCustomNodeFactory } from '../../../types/container/TCustomNodeFactory';
+
+import { IOptions } from '../../../interfaces/options/IOptions';
+
+import { AbstractDeadCodeInjectionReplacer } from './AbstractDeadCodeInjectionReplacer';
+
+@injectable()
+export class IfStatementDeadCodeInjectionReplacer extends AbstractDeadCodeInjectionReplacer {
+    /**
+     * @param customNodeFactory
+     * @param options
+     */
+    constructor (
+        @inject(ServiceIdentifiers.Factory__ICustomNode) customNodeFactory: TCustomNodeFactory,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(customNodeFactory, options);
+    }
+
+    /**
+     * @param ifStatementNode
+     * @param parentNode
+     * @returns {ESTree.Node}
+     */
+    public replace (ifStatementNode: ESTree.IfStatement, parentNode: ESTree.Node): ESTree.Node {
+        return ifStatementNode;
+    }
+}

src/types/container/TDeadCodeInjectionReplacerFactory.d.ts

@@ -0,0 +1,5 @@
+import { IDeadCodeInjectionReplacer } from '../../interfaces/node-transformers/IDeadCodeInjectionReplacer';
+
+import { DeadCodeInjectionReplacers } from '../../enums/container/DeadCodeInjectionReplacers';
+
+export type TDeadCodeInjectionReplacerFactory = (replacer: DeadCodeInjectionReplacers) => IDeadCodeInjectionReplacer;