All files / src/node-obfuscators NodeObfuscator.js

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
 
1x
1x
1x
1x
 
353x
353x
353x
 
 
40x
 
 
 
 
 
40x
40x
40x
 
 
 
 
3428x
115x
115x
 
 
115x
 
 
115x
 
 
 
24x
 
 
133x
133x
2x
 
131x
 
 
143x
143x
 
 
143x
143x
82x
 
61x
 
 
61x
61x
16x
 
 
45x
45x
 
61x
61x
59x
 
2x
 
 
1x
 
E"use strict";
const estraverse = require('estraverse');
const JSFuck_1 = require("../enums/JSFuck");
const Nodes_1 = require("../Nodes");
const Utils_1 = require('../Utils');
class NodeObfuscator {
    constructor(nodes, options) {
        this.nodes = nodes;
        this.options = options;
    }
    isReservedName(name) {
        return this.options.get('reservedNames')
            .some((reservedName) => {
            return new RegExp(reservedName, 'g').test(name);
        });
    }
    storeIdentifiersNames(node, namesMap) {
        if (Nodes_1.Nodes.isIdentifierNode(node) && !this.isReservedName(node.name)) {
            namesMap.set(node.name, Utils_1.Utils.getRandomVariableName());
            return;
        }
        return estraverse.VisitorOption.Skip;
    }
    replaceIdentifiersWithRandomNames(node, parentNode, namesMap) {
        if (Nodes_1.Nodes.isIdentifierNode(node) && namesMap.has(node.name)) {
            const parentNodeIsPropertyNode = (Nodes_1.Nodes.isPropertyNode(parentNode) &&
                parentNode.key === node), parentNodeIsMemberExpressionNode = (Nodes_1.Nodes.isMemberExpressionNode(parentNode) &&
                parentNode.computed === false &&
                parentNode.property === node);
            if (parentNodeIsPropertyNode || parentNodeIsMemberExpressionNode) I{
                return;
            }
            node.name = namesMap.get(node.name);
        }
    }
    replaceLiteralBooleanWithJSFuck(nodeValue) {
        return nodeValue ? JSFuck_1.JSFuck.True : JSFuck_1.JSFuck.False;
    }
    replaceLiteralNumberWithHexadecimalValue(nodeValue) {
        const prefix = '0x';
        if (!Utils_1.Utils.isInteger(nodeValue)) {
            return String(nodeValue);
        }
        return `${prefix}${Utils_1.Utils.decToHex(nodeValue)}`;
    }
    replaceLiteralValueWithUnicodeValue(nodeValue) {
        let value = nodeValue, replaceWithUnicodeArrayFlag = Math.random() <= this.options.get('unicodeArrayThreshold');
        if (this.options.get('encodeUnicodeLiterals') && replaceWithUnicodeArrayFlag) I{
            value = Utils_1.Utils.btoa(value);
        }
        value = Utils_1.Utils.stringToUnicode(value);
        if (!this.options.get('unicodeArray') || !replaceWithUnicodeArrayFlag) {
            return value;
        }
        return this.replaceLiteralValueWithUnicodeArrayCall(value);
    }
    replaceLiteralValueWithUnicodeArrayCall(value) {
        let unicodeArrayNode = this.nodes.get('unicodeArrayNode'), unicodeArray = unicodeArrayNode.getNodeData(), sameIndex = unicodeArray.indexOf(value), index, hexadecimalIndex;
        if (sameIndex >= 0) {
            index = sameIndex;
        }
        else {
            index = unicodeArray.length;
            unicodeArrayNode.updateNodeData(value);
        }
        hexadecimalIndex = this.replaceLiteralNumberWithHexadecimalValue(index);
        if (this.options.get('wrapUnicodeArrayCalls')) {
            return `${this.nodes.get('unicodeArrayCallsWrapper').getNodeIdentifier()}('${hexadecimalIndex}')`;
        }
        return `${unicodeArrayNode.getNodeIdentifier()}[${hexadecimalIndex}]`;
    }
}
exports.NodeObfuscator = NodeObfuscator;
//# sourceMappingURL=NodeObfuscator.js.map