@dacely/toildefender 0.1.0

package/processors/health.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var assert = require("assert");
+
+var _ = require("lodash");
+var escodegen = require("escodegen");
+
+var estest = require("../estest");
+var traverser = require("../traverser");
+
+
+module.exports = class Health {
+
+    constructor (logger) {
+        this.logger = logger;
+        this.strict = false;
+    }
+    
+    throwError (msg) {
+        if (this.strict) {
+            throw new Error(msg);
+        } else {
+            this.logger.warn(msg);
+        }
+    }
+    
+    /**
+     * Perform various health checks on the AST without modifying it.
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    check (ast) {
+        var visited = [];
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (_.includes(visited, node)) {
+                this.throwError("Node has multiple parents: " + JSON.stringify(node));
+            } else {
+                visited.push(node);
+            }
+            
+            if (node.type == "BlockStatement") {
+                node.body.forEach(stmt => {
+                    if (!estest.isStatement(stmt)) {
+                        this.throwError(JSON.stringify(stack[1], null, 2));
+                    }
+                });
+            }
+            
+            return node;
+        });
+        
+        return ast;
+    }
+};

package/processors/identifiers.js

@@ -0,0 +1,256 @@
+"use strict";
+
+var assert = require("assert");
+
+var _ = require("lodash");
+
+var estest = require("../estest");
+var ESUtils = require("../esutils");
+var traverser = require("../traverser");
+var utils = require("../utils");
+
+function literal(value) {
+    return { type: "Literal", value: value };
+}
+
+function encodeObjectKey(key, salt, index) {
+    var encoded = [ key.length ^ ((salt + index * 131) & 65535) ];
+    for (var i = 0; i < key.length; i += 1) {
+        encoded.push(key.charCodeAt(i) ^ ((salt + index * 257 + i * 17) & 65535));
+    }
+    return encoded;
+}
+
+function objectKey(prop) {
+    return prop.key.name || prop.key.value;
+}
+
+function isBigIntLiteral(node) {
+    return node.type == "Literal" && typeof node.value == "bigint";
+}
+
+module.exports = class Identifiers {
+
+    constructor (logger) {
+        this.logger = logger;
+        this.esutils = new ESUtils(logger);
+    }
+    
+    /**
+     * This checks whether the given node has a parent that
+     * accepts undefined children without throwing errors.
+     * Those cannot be moved to separate variables without
+     * causing errors by assigning undefined variables
+     * to new variables.
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    hasParentAcceptingUndefined (node) {
+        var parent = this.esutils.getParent(node);
+        return parent
+            && parent.type == "UnaryExpression"
+            && _.includes([ "typeof", "delete" ], parent.operator);
+    }
+    
+    /**
+     * Replace property references like obj.prop with obj["prop"].
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    computeProperties (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        ast = traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "MemberExpression"
+                && !node.computed) {
+                assert(node.property.type == "Identifier");
+                node.property = { type: "Literal", value: node.property.name };
+                node.computed = true;
+            }
+            
+            return node;
+        });
+        
+        return ast;
+    }
+    
+    /**
+     * Replace objects with an array via veilmark$toObject.
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    arrayizeObjects (ast, options) {
+        assert.ok(estest.isNode(ast));
+        options = options || {};
+
+        ast = traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "ObjectExpression") {
+                if (options.objectPacking === false) {
+                    var arr = [];
+                    node.properties.forEach(prop => {
+                        arr.push(literal(objectKey(prop)));
+                        arr.push(prop.value);
+                    });
+                    return {
+                        type: "CallExpression",
+                        callee: { type: "Identifier", name: "veilmark$toObject"  },
+                        arguments: [
+                            {
+                                type: "ArrayExpression",
+                                elements: arr
+                            }
+                        ]
+                    };
+                }
+
+                var salt = utils.random(1, 65535);
+                var schema = [ salt, node.properties.length ];
+                var values = [];
+
+                node.properties.forEach(prop => {
+                    var key = objectKey(prop);
+                    encodeObjectKey(String(key), salt, values.length).forEach(value => schema.push(value));
+                    values.push(prop.value);
+                });
+
+                return {
+                    type: "CallExpression",
+                    callee: { type: "Identifier", name: "veilmark$toObject"  },
+                    arguments: [
+                        {
+                            type: "ArrayExpression",
+                            elements: schema.map(literal)
+                        },
+                        {
+                            type: "ArrayExpression",
+                            elements: values
+                        }
+                    ]
+                };
+            }
+            
+            return node;
+        });
+        
+        return ast;
+    }
+    
+    // This seems to be ununsed.
+    // TODO: Figure this out
+    moveIdentifiers (ast, scopeManager) {
+        assert.ok(estest.isNode(ast));
+        
+        var rng = new utils.UniqueRandomAlpha(3);
+        
+        this.esutils.setParentsRecursive(ast);
+        
+        scopeManager.scopes.forEach(scope => {
+            /**
+             * That could cause problems if there are multiple unresolved
+             * references with the same name. (is that even possible?)
+             */
+            
+            var replaced = new utils.HashMap();
+            
+            scope.references
+            .filter(reference => !utils.isResolvedReference(reference))
+            .forEach(reference => {
+                if (replaced.exists(reference.identifier.name)) {
+                    reference.identifier.name = replaced.get(reference.identifier.name);
+                } else if (!this.hasParentAcceptingUndefined(reference.identifier)) {
+                    var name = "$$ident$" + rng.get();
+                    replaced.set(reference.identifier.name, name);
+                    
+                    var init;
+                    if (reference.identifier.name == "undefined") {
+                        init = { type: "Identifier", name: "undefined" };
+                    } else {
+                        init = {
+                            type: "ConditionalExpression",
+                            test: {
+                                type: "BinaryExpression",
+                                operator: "!==",
+                                left: {
+                                    type: "UnaryExpression",
+                                    operator: "typeof",
+                                    prefix: true,
+                                    argument: { type: "Identifier", name: reference.identifier.name }
+                                },
+                                right: { type: "Literal", value: "undefined" }
+                            },
+                            consequent: { type: "Identifier", name: reference.identifier.name },
+                            alternate: { type: "Identifier", name: "undefined" }
+                        };
+                    }
+                                        
+                    this.esutils.insertIntoScope(scope, {
+                        type: "VariableDeclaration",
+                        kind: "var",
+                        declarations: [
+                            {
+                                type: "VariableDeclarator",
+                                id: { type: "Identifier", name: name },
+                                init: init
+                            }
+                        ]
+                    });
+                    
+                    reference.identifier.name = name;
+                }
+            });
+        });
+        
+        return ast;
+    }
+    
+    /**
+     * Move all literals into the veilmark$literals array.
+     * @param {Node} ast Root node
+     * @param {ScopeManager} scopeManager Scope manager
+     * @returns {Node} Root node
+     */
+    moveLiterals (ast, scopeManager) {
+        assert.ok(estest.isNode(ast));
+        
+        var rng = new utils.UniqueRandomAlpha(3);
+        
+        var vars = [];
+        
+        ast = traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "Literal" && !isBigIntLiteral(node) && stack.length > 0 && stack[1].node.type != "Property") {
+                var idx = vars.indexOf(node.value);
+                if (idx == -1) {
+                    idx = vars.length;
+                    vars.push(node.value);
+                }
+                
+                return {
+                    type: "MemberExpression",
+                    object: { type: "Identifier", name: "veilmark$literals" },
+                    property: { type: "Literal", value: idx },
+                    computed: true
+                };
+            }
+            
+            return node;
+        });
+        
+        ast.body.splice(0, 0, {
+            type: "VariableDeclaration",
+            kind: "var",
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "veilmark$literals" },
+                    init: {
+                        type: "ArrayExpression",
+                        elements: vars.map(x => ({ type: "Literal", value: x }))
+                    }
+                }
+            ]
+        });
+        
+        return ast;
+    }
+    
+};

package/processors/literalObfuscator.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var assert = require("assert");
+
+var esprima = require("esprima");
+
+module.exports = class LiteralObfuscator {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+    
+    /**
+     * Generate an obfuscated string generator
+     * @param {string} input
+     * @returns {Node}
+     */
+    obfuscateString1 (input) {
+        assert.equal(typeof input, "string");
+        
+        function is16Bit (s) {
+            return s.split("").some(x => x.charCodeAt(0) > 65536);
+        }
+        
+        var getCharCode = function (x) { return x.charCodeAt(0); };
+        var chars = input.split("").map(getCharCode);
+
+        var out = [];
+        for (var i = 0; i < input.length; i += 2) {
+            var n = chars[i] | (chars[i + 1] << 16);
+            out.push(n);
+        }
+        
+        return esprima.parse(`
+        var input = ${JSON.stringify(out)};
+        input.map(function(x) { return String.fromCharCode(x & ~0 >>> 16) + String.fromCharCode(x >> 16); }).join("");
+        `);
+    }
+    
+};

package/processors/literals.js

@@ -0,0 +1,233 @@
+"use strict";
+
+var assert = require("assert");
+
+var _ = require("lodash");
+
+var estest = require("../estest");
+var traverser = require("../traverser");
+var utils = require("../utils");
+
+/**
+ * Generate string generator from string.
+ * @param {string} str
+ * @returns {Node}
+ */
+function makeStringGenerator(str) {
+    assert.equal(typeof str, "string");
+    
+    var fragments = [];
+    
+    while (str.length > 0) {
+        var len = utils.random(1, 5);
+        fragments.push(str.substring(0, len));
+        str = str.substring(len);
+    }
+    
+    var block = {
+        type: "BlockStatement",
+        body: [
+            {
+                type: "VariableDeclaration",
+                kind: "var",
+                declarations: [
+                    {
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name: "str" },
+                        init: { type: "Literal", value: "" }
+                    }
+                ]
+            }
+        ]
+    };
+    
+    fragments.forEach(fragment => {
+        var decoded = makeStringByteArrayCall(fragment);
+        
+        block.body.push({
+            type: "ExpressionStatement",
+            expression: {
+                type: "BinaryExpression",
+                operator: "+=",
+                left: { type: "Identifier", name: "str" },
+                right: decoded
+            }
+        });
+    });
+    
+    block.body.push({
+        type: "ReturnStatement",
+        argument: { type: "Identifier", name: "str" }
+    });
+    
+    return {
+        type: "CallExpression",
+        arguments: [],
+        callee: {
+            type: "FunctionExpression",
+            params: [],
+            body: block
+        }
+    };
+}
+
+/**
+ * Generate unicode-escaped string generator from string.
+ * @param {string} str
+ * @returns {Node}
+ */
+function makeStringUnicode(str) {
+    assert.equal(typeof str, "string");
+    
+    return {
+        type: "CallExpression",
+        callee: { type: "Identifier", name: "eval" },
+        arguments: [
+            {
+                type: "Literal",
+                value: "\"" + str.split("").map(x => "\\x" + x.charCodeAt().toString(16)).join("") + "\""
+            }
+        ]
+    };
+}
+
+/**
+ * Generate URL-escaped string generator from string.
+ * @param {string} str
+ * @returns {Node}
+ */
+function makeStringUnescape(str) {
+    assert.equal(typeof str, "string");
+    
+    return {
+        type: "CallExpression",
+        callee: { type: "Identifier", name: "unescape" },
+        arguments: [
+            {
+                type: "Literal",
+                value: str.split("").map(x => "%" + x.charCodeAt().toString(16)).join("")
+            }
+        ]
+    };
+}
+
+/**
+ * Generate char-code-escaped char generator from char.
+ * @param {string} cha
+ * @returns {Node}
+ */
+function makeCharByte(cha) {
+    assert.equal(typeof cha, "string");
+    assert.equal(cha.length, 1);
+    
+    return {
+        type: "CallExpression",
+        callee: {
+            type: "MemberExpression",
+            computed: false,
+            object: { type: "Identifier", name: "String" },
+            property: { type: "Identifier", name: "fromCharCode" }
+        },
+        arguments: [
+            {
+                type: "Literal",
+                value: cha.charCodeAt(0)
+            }
+        ]
+    };
+}
+
+/**
+ * Generate char-code-escaped string generator from string.
+ * @param {string} str
+ * @returns {Node}
+ */
+function makeStringByteArrayCall(str) {
+    assert.equal(typeof str, "string");
+    
+    return {
+        type: "CallExpression",
+        callee: { type: "Identifier", name: "veilmark$fromCharCodes" },
+        arguments: str.split("").map(x => ({ type: "Literal", value: x.charCodeAt() }))
+    };
+}
+
+module.exports = class Literals {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+    
+    /**
+     * Move strings into $$strings array
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    extractStrings (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var global = { type: "Identifier", name: "$$strings" };
+        
+        var strings = [];
+        var stringMap = {};
+        
+        ast = traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "Literal" && typeof node.value == "string") {
+                var idx = stringMap["_" + node.value];
+                if (!idx) {
+                    stringMap["_" + node.value] = idx = strings.length;
+                    strings.push(node);
+                }
+                
+                return {
+                    type: "MemberExpression",
+                    computed: true,
+                    object: global,
+                    property: { type: "Literal", value: idx }
+                };
+            }
+            
+            return node;
+        });
+        
+        ast.body.splice(0, 0, {
+            type: "VariableDeclaration",
+            kind: "var",
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: global,
+                    init: {
+                        type: "ArrayExpression",
+                        elements: strings
+                    }
+                }
+            ]
+        });
+        
+        return ast;
+    }
+
+    /**
+     * Replace string literals with string generators.
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    generateStrings (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        ast = traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "Literal"
+                && typeof node.value == "string"
+                && stack.length > 1
+                && stack[1].node.type != "Property") {
+                return makeStringGenerator(node.value);
+            }
+            
+            return node;
+        });
+        
+        return ast;
+    }
+    
+};