@dacely/toildefender 0.1.0

package/processors/postprocessing.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var assert = require("assert");
+
+var _ = require("lodash");
+
+var estest = require("../estest");
+var traverser = require("../traverser");
+var utils = require("../utils");
+
+/**
+ * Merges nested bind calls like
+ * veilmark$bind(veilmark$bind(main, 1234), 5678)
+ * to
+ * veilmark$bind(main, 1234, 5678)
+ * @param {Node} node
+ * @returns {Node}
+ */
+function mergeNestedBinds(node) {
+    assert.ok(estest.isNode(node));
+    
+    if (isBindCall(node)) {
+        return mergeNestedBinds(node.arguments[0]).concat(node.arguments.slice(1)); 
+    } else {
+        return [ node ];
+    }
+}
+
+/**
+ * Checks whether node is a call to veilmark$bind.
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isBindCall(node) {
+    assert.ok(estest.isNode(node));
+    
+    return node.type == "CallExpression"
+        && node.callee.type == "Identifier"
+        && node.callee.name == "veilmark$bind";
+}
+
+module.exports = class Postprocessing {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+
+    /**
+     * Does postprocessing.
+     * @param {Node} ast Root node
+     * @return {Node} Root node
+     */
+    do (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        return traverser.traverse(ast, [], (node, stack) => {
+            if (isBindCall(node)) {
+                node.arguments = mergeNestedBinds(node);
+            } else if (node.type == "BlockStatement" || node.type == "Program") {
+                node.body = node.body.filter(x => estest.isNode(x) && x.type != "EmptyStatement");
+            } else if (node.type == "SwitchCase") {
+                node.consequent = node.consequent.filter(x => estest.isNode(x) && x.type != "EmptyStatement");
+            }
+            
+            return node;
+        });
+    }
+
+};

package/processors/preprocessing.js

@@ -0,0 +1,248 @@
+"use strict";
+
+var _ = require("lodash");
+
+var { Parser: Parser } = require("expr-eval");
+
+const DEFAULT_PREPROCESSOR_VARIABLES = {
+    "true": 1,
+    "false": 0
+};
+
+/**
+ * Generates code from an array of text nodes.
+ * @param {TextNode[]} nodes
+ * @returns {string}
+ */
+function codeFromNodeArray(nodes) {
+    let lines = [];
+    for (let node of nodes) {
+        lines[node.line] = node.text;
+    }
+    return lines.join("\n");
+}
+
+/**
+ * Removes shebang from beginning of code.
+ * @param {string} code
+ * @returns {string}
+ */
+function removeShebangs(code) {
+    if (_.startsWith(code, "#!")) {
+        code = code.split(/\r?\n/).slice(1).join("\n");
+    }
+
+    return code;
+}
+
+class ArrayUtils {
+    /**
+     * Replaces all occurences of an object in an array with an other object in place.
+     * @param {Array} arr
+     * @param {Object} oldElem
+     * @param {Object} newElem 
+     */
+    static replace(arr, oldElem, newElem) {
+        for (let i = 0; i < arr.length; ++i) {
+            if (arr[i] == oldElem) {
+                arr[i] = newElem;
+            }
+        }
+    }
+}
+
+class Node {
+    constructor() {
+
+    }
+    /**
+     * Evaluates tree into an array of TextNodes.
+     * @param {Object.<string, string>} defines Preprocessor variables
+     * @returns {TextNode[]}
+     */
+    eval(defines) {
+        throw new Error("Node.eval() can not be called directly");
+    }
+}
+
+class BlockNode extends Node {
+    constructor() {
+        super();
+        this.children = [];
+    }
+    eval(defines) {
+        return _.flatten(this.children.map(x => x.eval(defines)));
+    }
+}
+
+class TextNode extends Node {
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    eval(defines) {
+        return [this];
+    }
+}
+
+class DefineNode extends Node {
+    constructor(left, right) {
+        super();
+        this.left = left;
+        this.right = right;
+    }
+    eval(defines) {
+        defines[this.left] = this.right;
+        return [];
+    }
+}
+
+class ErrorNode extends Node {
+    constructor(message) {
+        super();
+        this.message = message;
+    }
+    eval(defines) {
+        throw new Error(this.message);
+    }
+}
+
+class IfBlockNode extends BlockNode {
+    constructor(condition) {
+        super();
+        this.condition = condition;
+    }
+    /**
+     * Evaluates condition.
+     * @param {Object.<string, string>} defines Preprocessor variables
+     * @returns {boolean}
+     */
+    evalCond(defines) {
+        let condition = this.condition;
+        condition = condition.replace(/!defined\(([\w\d]+)\)/, (match, p1) => !defines.hasOwnProperty(p1) ? "true" : "false");
+        condition = condition.replace(/defined\(([\w\d]+)\)/, (match, p1) => defines.hasOwnProperty(p1) ? "true" : "false");
+        return Parser.evaluate(condition, defines);
+    }
+    /**
+     * Evaluates node with given condition result.
+     * @param {Object.<string, string>} defines Preprocessor variables
+     * @returns {boolean}
+     */
+    evalWith(defines, result) {
+        if (result) {
+            return super.eval(defines);
+        } else {
+            return [];
+        }
+    }
+    eval(defines) {
+        return this.evalWith(defines, this.evalCond(defines));
+    }
+}
+
+class ElseBlockNode extends BlockNode {
+    constructor(ifNode) {
+        super();
+        this.ifNode = ifNode;
+    }
+    eval(defines) {
+        if (this.ifNode.evalCond(defines)) {
+            return this.ifNode.evalWith(defines, true);
+        } else {
+            return super.eval(defines);
+        }
+    }
+}
+
+module.exports = class Preprocessing {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+    
+    /**
+     * Processes preprocessor directives.
+     * @param {string} code
+     * @param {Object.<string, string>} preprocessorVariables
+     * @returns {string} Processed code
+     */
+    processDirectives (code, preprocessorVariables) {
+        let lines = code.split(/\r?\n/), stack = [new BlockNode()];
+
+        let defines = {};
+        _.merge(defines, DEFAULT_PREPROCESSOR_VARIABLES);
+        _.merge(defines, preprocessorVariables);
+
+        for (let i = 0; i < lines.length; ++i) {
+            let line = lines[i];
+            let [, directive, parameters] = /^\s*\/\/\s*#(\w+)\s*(.+)?$/.exec(line) || [];
+            switch (directive) {
+                case undefined: {
+                    let elem = new TextNode(line);
+                    elem.line = i;
+                    _.last(stack).children.push(elem);
+                    break;
+                }
+                case "define": {
+                    let [, left, right] = /^\s*([\w\d]+)\s*(?:=\s*([\w\d]+))?\s*$/.exec(parameters);
+                    let elem = new DefineNode(left, right);
+                    elem.line = i;
+                    _.last(stack).children.push(elem);
+                    break;
+                }
+                case "error": {
+                    let elem = new ErrorNode(parameters);
+                    elem.line = i;
+                    _.last(stack).children.push(elem);
+                    break;
+                }
+                case "if":
+                case "ifdef":
+                case "ifndef": {
+                    let elem =
+                        directive == "if" ? new IfBlockNode(parameters) :
+                        directive == "ifdef" ? new IfBlockNode(`defined(${parameters})`) :
+                        directive == "ifndef" ? new IfBlockNode(`!defined(${parameters})`) :
+                        null;
+                    elem.line = i;
+                    _.last(stack).children.push(elem);
+                    stack.push(elem);
+                    break;
+                }
+                case "else": {
+                    let elem = new ElseBlockNode(stack.pop());
+                    elem.line = i;
+                    ArrayUtils.replace(_.last(stack).children, elem.ifNode, elem);
+                    stack.push(elem);
+                    break;
+                }
+                case "endif": {
+                    let elem = stack.pop();
+                    break;
+                }
+                default: {
+                    this.logger.warn(`Unknown preprocessor directive #${directive}`);
+                }
+            }
+        }
+
+        if (stack.length > 1) {
+            this.logger.warn("stack.length != 1 (preprocessor directive closing tag missing?)");
+        }
+
+        return codeFromNodeArray(stack[0].eval(defines));
+    }
+
+    /**
+     * Does preprocessing.
+     * @param {string} code
+     * @param {Object.<string, string>} preprocessorVariables
+     * @returns {string}
+     */
+    process (code, preprocessorVariables) {
+        code = this.processDirectives(code, preprocessorVariables);
+        code = removeShebangs(code);
+        return code;
+    }
+    
+};

package/processors/scopes.js

@@ -0,0 +1,177 @@
+"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");
+
+module.exports = class Scopes {
+
+    constructor (logger) {
+        this.logger = logger;
+        this.esutils = new ESUtils(logger);
+    }
+
+    /**
+     * Moves all variables to scope arrays like
+     * var a = 1, b = 2;
+     * to
+     * var $$scope$abc = [];
+     * $$scope$abc[0] = 1;
+     * $$scope$abc[1] = 2;
+     * @param {Node} ast Root node
+     * @param {ScopeManager} scopeManager Scope manager
+     */
+    createScopeObjects (ast, scopeManager) {
+        assert.ok(estest.isNode(ast));
+        
+        this.esutils.setParentsRecursive(ast);
+        var scopes = scopeManager.acquireAll(ast);
+        var rngAlpha = new utils.UniqueRandomAlpha(3);
+        scopeManager.scopes.forEach(scope => {
+            var scopeVarName = `$$scope$${rngAlpha.get()}`;
+            
+            var counter = 0;
+            var scopeDecl = {
+                type: "VariableDeclaration",
+                kind: "var",
+                declarations: [
+                    {
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name: scopeVarName },
+                        init: { type: "ArrayExpression", elements: [] }
+                    }
+                ],
+                veilmark$scopeObject: true
+            };
+            
+            this.esutils.insertIntoScope(scope, scopeDecl);
+            
+            scope.variables.forEach(variable => {
+                var index = counter++;
+                
+                variable.defs.forEach(def => {
+                    if (def.type == "Variable") {
+                        assert(def.parent.type == "VariableDeclaration");
+                        def.parent.declarations = def.parent.declarations.filter(x => x != def.node);
+                        var replacement = [];
+                        if (def.node.init) {
+                            replacement.push({
+                                type: "ExpressionStatement",
+                                expression: {
+                                    type: "AssignmentExpression",
+                                    operator: "=",
+                                    left: {
+                                        type: "MemberExpression",
+                                        object: { type: "Identifier", name: scopeVarName },
+                                        property: { type: "Literal", value: index },
+                                        computed: true,
+                                        veilmark$scopeObjectReference: true
+                                    },
+                                    right: def.node.init
+                                }
+                            });
+                        }
+                        if (def.parent.declarations.length > 0) {
+                            replacement.push(def.parent);
+                        }
+                        if (replacement.length == 0) {
+                            this.esutils.replaceNode(scope.block, def.parent, { type: "EmptyStatement" });
+                        } else if (replacement.length == 1) {
+                            this.esutils.replaceNode(scope.block, def.parent, replacement[0] );
+                        } else {
+                            this.esutils.replaceNode(scope.block, def.parent, { type: "BlockStatement", body: replacement });
+                        }
+                        variable.references.forEach(reference => {
+                            // References can not be replaced via replaceNodeEx for whatever reason
+                            this.esutils.replaceNode(scope.block, reference.identifier, {
+                                type: "MemberExpression",
+                                object: { type: "Identifier", name: scopeVarName },
+                                property: { type: "Literal", value: index },
+                                computed: true,
+                                veilmark$scopeObjectReference: true
+                            });
+                        });
+                    } else if (def.type == "CatchClause") {
+                        Object.defineProperty(scope.block, "veilmark$exception", {
+                            value: {
+                                type: "MemberExpression",
+                                object: { type: "Identifier", name: scopeVarName },
+                                property: { type: "Literal", value: index },
+                                computed: true,
+                                veilmark$scopeObjectReference: true
+                            },
+                            configurable: true
+                        });
+                        this.esutils.insertIntoScope(scope, {
+                            type: "ExpressionStatement",
+                            expression: {
+                                type: "AssignmentExpression",
+                                operator: "=",
+                                left: {
+                                    type: "MemberExpression",
+                                    object: { type: "Identifier", name: scopeVarName },
+                                    property: { type: "Literal", value: index },
+                                    computed: true,
+                                    veilmark$scopeObjectReference: true
+                                },
+                                right: def.name
+                            }
+                        }, 1);
+                        variable.references.forEach(reference => {
+                            this.esutils.replaceNode(scope.block, reference.identifier, {
+                                type: "MemberExpression",
+                                object: { type: "Identifier", name: scopeVarName },
+                                property: { type: "Literal", value: index },
+                                computed: true,
+                                veilmark$scopeObjectReference: true
+                            });
+                        });
+                    } else if (def.type == "FunctionName") {
+                        variable.references.forEach(reference => {
+                            this.esutils.replaceNode(scope.block, reference.identifier, {
+                                type: "CallExpression",
+                                callee: { type: "Identifier", name: "veilmark$bind" },
+                                arguments: [
+                                    reference.identifier,
+                                    { type: "Identifier", name: scopeVarName }
+                                ]
+                            });
+                        });
+                    }
+                });
+            });
+            
+            traverser.traverse(scope.block, [], (node, stack) => {
+                if (scope.block == node) {
+                    return node;
+                }
+                
+                if (node.type.indexOf("Function") == 0) {
+                    node.params.unshift({
+                        type: "Identifier",
+                        name: scopeVarName
+                    });
+                }
+                
+                if (node.type == "FunctionExpression") {
+                    return {
+                        type: "CallExpression",
+                        callee: { type: "Identifier", name: "veilmark$bind" },
+                        arguments: [
+                            node,
+                            { type: "Identifier", name: scopeVarName }
+                        ]
+                    };
+                }
+                
+                return node;
+            });
+        });
+    }
+
+};

package/processors/uglifier.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var assert = require("assert");
+
+var esshorten = require("esshorten");
+
+var estest = require("../estest");
+
+module.exports = class Uglifier {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+
+    /**
+     * Uglifies tree.
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    uglify (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        return esshorten.mangle(ast);
+    }
+
+};

package/processors/variables.js

@@ -0,0 +1,185 @@
+"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");
+
+module.exports = class Variables {
+
+    constructor (logger) {
+        this.logger = logger;
+        this.esutils = new ESUtils(logger);
+    }
+    
+    /**
+     * Removes the id property from FunctionExpressions.
+     * They trip up functionDeclarationToExpression and escope (?),
+     * causing scopes.js to incorrectly rename some references.
+     * @param {Node} ast Root node
+     * @returns {Node} Root node
+     */
+    removeFunctionExpressionIds (ast) {
+        return traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "FunctionExpression" && node.id) {
+                node.id = null;
+            }
+            return node;
+        });
+    }
+
+    /**
+     * Converts function declarations like
+     * function test() { ... }
+     * to function expression variables like
+     * var test = function() { ... };
+     * @param {Node} ast Root node
+     * @param {ScopeManager} scopeManager Scope manager
+     */
+    functionDeclarationToExpression (ast, scopeManager) {
+        assert.ok(estest.isNode(ast));
+        
+        this.esutils.setParentsRecursive(ast);
+        
+        scopeManager.scopes.forEach(scope => {
+            scope.variables.forEach(variable => {
+                variable.defs.forEach(def => {
+                    if (def.type == "FunctionName") {
+                        assert(estest.isFunction(def.node));
+                        /**
+                         * Here you have to ensure that def.node is statement.
+                         * Expressions like { foo: function() { ... }} are parsed
+                         * as a FunctionExpression with an id, which are then
+                         * mistakingly replaced with EmptyStatements.
+                         */
+                        if (estest.isStatement(def.node)) {
+                            this.esutils.replaceNode(ast, def.node, { type: "EmptyStatement" });
+                            this.esutils.insertIntoScope(scope, {
+                                type: "VariableDeclaration",
+                                kind: "var",
+                                declarations: [
+                                    {
+                                        type: "VariableDeclarator",
+                                        id: def.node.id,
+                                        init: {
+                                            type: "FunctionExpression",
+                                            params: def.node.params,
+                                            body: def.node.body
+                                        }
+                                    }
+                                ]
+                            });
+                        }
+                    }
+                });
+            });
+        });
+    }
+
+    /**
+     * Renames identifiers with unique names, e.g.
+     * var a, b = 5;
+     * to
+     * var $$var$123$a, $$var$123$b = 5;
+     * @param {Node} ast Root node
+     * @param {ScopeManager} scopeManager Scope manager
+     */
+    obfuscateIdentifiers (ast, scopeManager) {
+        scopeManager.scopes.forEach(scope => {
+            if (scope.isStatic()) {
+                scope.variables.sort((a, b) => {
+                    if (a.tainted) {
+                        return 1;
+                    }
+                    if (b.tainted) {
+                        return -1;
+                    }
+                    return (b.identifiers.length + b.references.length) - (a.identifiers.length + a.references.length);
+                });
+
+                for (let variable of scope.variables) {
+                    var name = "$$var$" + utils.hash(variable) + "$" + variable.name;
+
+                    if (variable.tainted) {
+                        continue;
+                    }
+
+                    if (variable.identifiers.length === 0) {
+                        // do not change names since this is a special name
+                        continue;
+                    }
+
+                    for (let def of variable.identifiers) {
+                        // change definition's name
+                        def.name = name;
+                    }
+
+                    for (let ref of variable.references) {
+                        // change reference's name
+                        ref.identifier.name = name;
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * Replaces direct parameter references like
+     * function (a) {
+     *     return a;
+     * }
+     * to copys like
+     * function (a) {
+     *     var $$arg$abc = a;
+     *     return $$arg$abc;
+     * }
+     * @param {Node} ast Root node
+     * @param {ScopeManager} scopeManager Scope manager
+     */
+    redefineParameters (ast, scopeManager) {
+        function getArgumentIndex(method, identifier) {
+            assert(method.type == "FunctionDeclaration" || method.type == "FunctionExpression");
+            assert(identifier.type == "Identifier");
+            for (var i = 0; i < method.params.length; ++i) {
+                if (method.params[i].name == identifier.name) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+        
+        var rng = new utils.UniqueRandomAlpha(3);
+        
+        scopeManager.scopes.forEach(scope => {
+            scope.variables.forEach(variable => {
+                variable.defs.forEach(def => {
+                    if (def.type == "Parameter") {
+                        assert(def.name.type == "Identifier");
+                        var name = "$$arg$" + rng.get();
+                        
+                        this.esutils.insertIntoScope(scope, {
+                            type: "VariableDeclaration",
+                            kind: "var",
+                            declarations: [
+                                {
+                                    type: "VariableDeclarator",
+                                    id: { type: "Identifier", name: name },
+                                    init: def.name
+                                }
+                            ]
+                        });
+                        
+                        variable.references.forEach(reference => {
+                            reference.identifier.name = name;
+                        });
+                    }
+                });
+            });
+        });
+    }
+
+};