Code coverage report for src/custom-nodes/debug-protection-nodes/group/DebugProtectionCustomNodeGroup.ts

# All files / src/custom-nodes/debug-protection-nodes/group DebugProtectionCustomNodeGroup.ts

89.74% Statements 35/39
75% Branches 3/4
75% Functions 3/4
88.89% Lines 32/36

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    1101x
    1x

    1x

    1x
    1x

    1x
    1x
    1x

    1x

    6265x

    1x

    6265x

    6265x
    6265x

    6262x
    1x

    6262x
    1x

    6262x

    6262x

    6262x
    6261x

    1x

    1x
    1x
    1x

    1x
    1x
    1x

    1x
    1x

    1x

     import { injectable, inject } from 'inversify';
    import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';

    import { TCustomNodeFactory } from '../../../types/container/TCustomNodeFactory';
    import { TNodeWithBlockStatement } from '../../../types/node/TNodeWithBlockStatement';
    import { TObfuscationEvent } from '../../../types/event-emitters/TObfuscationEvent';

    import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
    import { IObfuscationEventEmitter } from '../../../interfaces/event-emitters/IObfuscationEventEmitter';
    import { IOptions } from '../../../interfaces/options/IOptions';
    import { IStackTraceData } from '../../../interfaces/stack-trace-analyzer/IStackTraceData';

    import { initializable } from '../../../decorators/Initializable';

    import { CustomNodes } from '../../../enums/container/CustomNodes';
    import { ObfuscationEvents } from '../../../enums/ObfuscationEvents';

    import { AbstractCustomNodeGroup } from '../../AbstractCustomNodeGroup';
    import { NodeAppender } from '../../../node/NodeAppender';
    import { RandomGeneratorUtils } from '../../../utils/RandomGeneratorUtils';

    @injectable()
    export class DebugProtectionCustomNodeGroup extends AbstractCustomNodeGroup {
        /**
         * @type {TObfuscationEvent}
         */
        protected readonly appendEvent: TObfuscationEvent = ObfuscationEvents.BeforeObfuscation;

        /**
         * @type {Map<CustomNodes, ICustomNode>}
         */
        @initializable()
        protected customNodes: Map <CustomNodes, ICustomNode>;

        /**
         * @type {TCustomNodeFactory}
         */
        private readonly customNodeFactory: TCustomNodeFactory;

        /**
         * @type {IObfuscationEventEmitter}
         */
        private readonly obfuscationEventEmitter: IObfuscationEventEmitter;

        /**
         * @param customNodeFactory
         * @param obfuscationEventEmitter
         * @param options
         */
        constructor (
            @inject(ServiceIdentifiers.Factory__ICustomNode) customNodeFactory: TCustomNodeFactory,
            @inject(ServiceIdentifiers.IObfuscationEventEmitter) obfuscationEventEmitter: IObfuscationEventEmitter,
            @inject(ServiceIdentifiers.IOptions) options: IOptions
        ) {
            super(options);

            this.customNodeFactory = customNodeFactory;
            this.obfuscationEventEmitter = obfuscationEventEmitter;
        }

        /**
         * @param blockScopeNode
         * @param stackTraceData
         */
        public appendCustomNodes (blockScopeNode: TNodeWithBlockStatement, stackTraceData: IStackTraceData[]): void {
            // debugProtectionFunctionNode append
            this.appendCustomNodeIfExist(CustomNodes.DebugProtectionFunctionNode, (customNode: ICustomNode) => {
                NodeAppender.appendNode(blockScopeNode, customNode.getNode());
            });

            // debugProtectionFunctionCallNode append
            this.appendCustomNodeIfExist(CustomNodes.DebugProtectionFunctionCallNode, (customNode: ICustomNode) => {
                NodeAppender.appendNode(blockScopeNode, customNode.getNode());
            });

            // debugProtectionFunctionIntervalNode append
            this.appendCustomNodeIfExist(CustomNodes.DebugProtectionFunctionIntervalNode, (customNode: ICustomNode) => {
                const programBodyLength: number = blockScopeNode.body.length;
                const randomIndex: number = RandomGeneratorUtils.getRandomInteger(0, programBodyLength);

                NodeAppender.insertNodeAtIndex(blockScopeNode, customNode.getNode(), randomIndex);
            });
        }

        public initialize (): void {
            this.customNodes = new Map <CustomNodes, ICustomNode> ();

            if (!this.options.debugProtection) {
                return;
            }

            const debugProtectionFunctionName: string = RandomGeneratorUtils.getRandomVariableName(6);

            const debugProtectionFunctionNode: ICustomNode = this.customNodeFactory(CustomNodes.DebugProtectionFunctionNode);
            const debugProtectionFunctionCallNode: ICustomNode = this.customNodeFactory(CustomNodes.DebugProtectionFunctionCallNode);
            const debugProtectionFunctionIntervalNode: ICustomNode = this.customNodeFactory(CustomNodes.DebugProtectionFunctionIntervalNode);

            debugProtectionFunctionNode.initialize(debugProtectionFunctionName);
            debugProtectionFunctionCallNode.initialize(debugProtectionFunctionName);
            debugProtectionFunctionIntervalNode.initialize(debugProtectionFunctionName);

            this.customNodes.set(CustomNodes.DebugProtectionFunctionNode, debugProtectionFunctionNode);
            this.customNodes.set(CustomNodes.DebugProtectionFunctionCallNode, debugProtectionFunctionCallNode);

            Iif (this.options.debugProtectionInterval) {
                this.customNodes.set(CustomNodes.DebugProtectionFunctionIntervalNode, debugProtectionFunctionIntervalNode);
            }
        }
    }