# All files / src/node-transformers/node-obfuscators ObjectExpressionObfuscator.ts

100% Statements 28/28
80% Branches 8/10
100% Functions 3/3
100% Lines 25/25

    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
    951x
    1x

    1x
    1x

    1x

    1x
    1x
    1x

    1x

    729x

    2254x

    2400x
    2028x

    2400x

    2400x
    2x

    2x

    2398x
    2398x

    2x
    2x

    2398x
    2398x

    2398x

    2398x

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

    import * as escodegen from 'escodegen';
    import * as estraverse from 'estraverse';
    import * as ESTree from 'estree';

    import { IOptions } from '../../interfaces/options/IOptions';

    import { NodeType } from '../../enums/NodeType';

    import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
    import { Node } from '../../node/Node';
    import { Utils } from '../../utils/Utils';

    /**
     * replaces:
     *     var object = { 'PSEUDO': 1 };
     *
     * or:
     *     var object = { PSEUDO: 1 };
     *
     * on:
     *     var object = { '\u0050\u0053\u0045\u0055\u0044\u004f': 1 };
     */
    @injectable()
    export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
        /**
         * @param options
         */
        constructor(
            @inject(ServiceIdentifiers.IOptions) options: IOptions
        ) {
            super(options);
        }

        /**
         * @param objectExpressionNode
         */
        public transformNode (objectExpressionNode: ESTree.ObjectExpression): void {
            objectExpressionNode.properties
                .forEach((property: ESTree.Property) => {
                    if (property.shorthand) {
                        property.shorthand = false;
                    }

                    estraverse.traverse(property.key, {
                        enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
                            if (Node.isLiteralNode(node)) {
                                this.obfuscateLiteralPropertyKey(node);

                                return;
                            }

                            Eif (Node.isIdentifierNode(node)) {
                                this.obfuscateIdentifierPropertyKey(node);
                            }
                        }
                    });
                });
        }

        /**
         * @param node
         */
        private obfuscateLiteralPropertyKey (node: ESTree.Literal): void {
            Eif (typeof node.value === 'string' && !node['x-verbatim-property']) {
                node['x-verbatim-property'] = {
                    content : `'${Utils.stringToUnicodeEscapeSequence(node.value)}'`,
                    precedence: escodegen.Precedence.Primary
                };
            }
        }

        /**
         * @param node
         */
        private obfuscateIdentifierPropertyKey (node: ESTree.Identifier): void {
            const nodeValue: string = node.name;
            const literalNode: ESTree.Literal = {
                raw: `'${nodeValue}'`,
                'x-verbatim-property': {
                    content : `'${Utils.stringToUnicodeEscapeSequence(nodeValue)}'`,
                    precedence: escodegen.Precedence.Primary
                },
                type: NodeType.Literal,
                value: nodeValue
            };

            delete node.name;

            Object.assign(node, literalNode);
        }
    }