@dacely/toildefender 0.1.0

package/processors/methods.js

@@ -0,0 +1,332 @@
+"use strict";
+
+const METHODS_INJECT = `
+function veilmark$mergeArguments(a, b) {
+    return Array.prototype.slice.call(a).concat(Array.prototype.slice.call(b));
+}
+
+function veilmark$bind() {
+    var fn = arguments[0], prepend = Array.prototype.slice.call(arguments, 1);
+    var wrapper = function() {
+        return fn.apply(this, prepend.concat(Array.prototype.slice.call(arguments)));
+    };
+    wrapper.prototype = fn.prototype;
+    return wrapper;
+}
+
+function veilmark$sliceArguments(args, num) {
+    return Array.prototype.slice.call(args, num);
+}
+
+function veilmark$toObject(schema, values) {
+    var obj = {};
+    if (values === undefined) {
+        for (var legacy = 0; legacy < schema.length; legacy += 2) {
+            obj[schema[legacy]] = schema[legacy + 1];
+        }
+        return obj;
+    }
+    var cursor = 2;
+    var salt = schema[0];
+    var count = schema[1];
+    for (var i = 0; i < count; i += 1) {
+        var len = schema[cursor++] ^ ((salt + i * 131) & 65535);
+        var key = "";
+        for (var j = 0; j < len; j += 1) {
+            key += String.fromCharCode(schema[cursor++] ^ ((salt + i * 257 + j * 17) & 65535));
+        }
+        obj[key] = values[i];
+    }
+    return obj;
+}
+
+function veilmark$decodeString(arr) {
+    return arr.map(function(x) { return String.fromCharCode(x & ~0 >>> 16) + String.fromCharCode(x >> 16); }).join("");
+}
+
+function veilmark$fromCharCodes() {
+    return String.fromCharCode.apply(null, arguments);
+}
+
+`;
+
+var assert = require("assert");
+var fs = require("fs");
+
+var _ = require("lodash");
+var escope = require("escope");
+var esprima = require("esprima");
+
+var estest = require("../estest");
+var traverser = require("../traverser");
+var utils = require("../utils");
+
+const ANON_METHOD_ID = "veilmark$anonymousMethodId";
+
+/**
+ * Wrap function with veilmark$bind.
+ * @param {Identifier} Function identifier
+ * @returns {Node} Wrapped function
+ */
+function createMethodStub(id) {
+    assert.equal(id.type, "Identifier");
+    
+    return {
+        type: "CallExpression",
+        callee: { type: "Identifier", name: "veilmark$bind" },
+        arguments: [
+            id
+        ]
+    };
+}
+
+function anonymousMethodName(node) {
+    assert.equal(node.type, "FunctionExpression");
+
+    if (!node[ANON_METHOD_ID]) {
+        Object.defineProperty(node, ANON_METHOD_ID, {
+            configurable: false,
+            enumerable: false,
+            value: `veilmark$anon$${utils.hash(node)}`
+        });
+    }
+
+    return node[ANON_METHOD_ID];
+}
+
+/**
+ * Get index of argument in function.
+ * @param {Function} method Function
+ * @param {Identifier} identifier} Argument identifier
+ * @returns {number} Index of argument
+ */
+function getArgumentIndex(method, identifier) {
+    assert.ok(estest.isFunction(method));
+    assert.equal(identifier.type, "Identifier");
+    
+    return _.findIndex(method.params, x => x.name == identifier.name);
+}
+
+function rawArgumentsIdentifier() {
+    return {
+        type: "Identifier",
+        name: "arguments",
+        veilmark$rawArguments: true
+    };
+}
+
+module.exports = class Methods {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+    
+    /**
+     * Adds helper methods to the beginning of the app.
+     * @param {Node} Root node
+     */
+    addCustomBind (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var code = esprima.parse(METHODS_INJECT);
+        code.type = "BlockStatement";
+        ast.body.splice(0, 0, code);
+    }
+    
+    /**
+     * Checks whether a method refers to the "arguments" array.
+     * @param {Function} method
+     * @param {ScopeManager} scopeManager
+     * @returns {boolean}
+     */
+    methodRefersToArguments (method, scopeManager) {
+        assert.ok(estest.isFunction(method));
+        assert.ok(scopeManager);
+        
+        return scopeManager
+        .acquire(method)
+        .references
+        .some(reference => !utils.isResolvedReference(reference) && reference.identifier.name == "arguments");
+    }
+    
+    /**
+     * Inserts code to copy/slice arguments from the arguments array like
+     * function () { ... }
+     * to
+     * function () { var veilmark$arguments = veilmark$sliceArguments(arguments, 1); ... }
+     * @param {Function} method
+     * @param {number} num Number of arguments to be sliced off. 0 if none.
+     */
+    removeFirstArguments (method, num) {
+        assert.ok(estest.isFunction(method));
+        assert.equal(typeof num, "number");
+        
+        method.body.body.splice(0, 0, {
+            type: "VariableDeclaration",
+            kind: "var",
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "veilmark$arguments" },
+                    init: rawArgumentsIdentifier()
+                },
+                {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "veilmark$bareArguments" },
+                    init: num > 0 ? {
+                        type: "CallExpression",
+                        callee: { type: "Identifier", name: "veilmark$sliceArguments" },
+                        arguments: [
+                            rawArgumentsIdentifier(),
+                            { type: "Literal", value: num, veilmark$removeFirstArguments: true }
+                        ]
+                    } : rawArgumentsIdentifier()
+                }
+            ],
+            veilmark$reassigningArguments: true,
+            veilmark$followsSlicingArguments: num > 0
+        });
+    }
+
+    /**
+     * Lists all methods.
+     * @param {Node} ast Root node
+     * @returns {string[]} Method names
+     */
+    listMethods (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var methods = [];
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "FunctionDeclaration") { // Statement
+                methods.push(node.id.name);
+            } else if (node.type == "FunctionExpression") { // Expression
+                methods.push(anonymousMethodName(node));
+            }
+            
+            return node;
+        });
+        
+        return methods;
+    }
+
+    /**
+     * Extracts all methods from the AST.
+     * @param {Node} ast Root node
+     * @returns {Function[]}
+     */
+    extractMethods (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var methods = [];
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "FunctionDeclaration") { // Statement
+                methods.push(node);
+                return { type: "ExpressionStatement", expression: createMethodStub(node.id) }; // This is not ideal
+            } else if (node.type == "FunctionExpression") { // Expression
+                var id = anonymousMethodName(node);
+                // Merge into old object instead of creating a new one to preserve object references
+                methods.push(_.assign(node, {
+                    type: "FunctionDeclaration",
+                    id: { type: "Identifier", name: id }
+                }));
+                return createMethodStub({ type: "Identifier", name: id });
+            }
+            
+            return node;
+        });
+        
+        return methods;
+    }
+
+    /**
+     * Replaces direct argument references with arguments references like
+     * function (a) { return a; }
+     * to
+     * function (a) { return veilmark$arguments[0]; }
+     * @param {Function} method Function whose body will be transformed
+     * @param {boolean} useReassignedVariable Use veilmark$arguments instead of arguments
+     * @returns {Function} Function from method parameter
+     */
+    replaceArgumentReferences (method, useReassignedVariable) {
+        assert.ok(estest.isFunction(method));
+        
+        traverser.traverse(method.body, [], (node, stack) => {
+            if (node.type == "Identifier") {
+                var nestedFunction = stack.some(frame => estest.isFunction(frame.node));
+                if (useReassignedVariable && node.name == "arguments" && !node.veilmark$rawArguments && !nestedFunction) {
+                    return { type: "Identifier", name: "veilmark$bareArguments" };
+                }
+                var index = getArgumentIndex(method, node);
+                if (index != -1) {
+                    return {
+                        type: "MemberExpression",
+                        object: { type: "Identifier", name: useReassignedVariable ? "veilmark$arguments" : "arguments" },
+                        property: { type: "Literal", value: index },
+                        computed: true
+                    };
+                }
+            }
+            
+            return node;
+        });
+        
+        method.params = [];
+        
+        return method;
+    }
+
+    /**
+     * Replaces function calls with main calls like
+     * test()
+     * to
+     * veilmark$bind(main, 1234)()
+     * @param {Node} ast Root node
+     * @param {Object[]} methodEntryExitPoints Method entry point table
+     * @param {number} methodEntryExitPoints[].entry Entry point
+     */
+    replaceFunctionCalls (ast, methodEntryExitPoints) {
+        assert.ok(estest.isNode(ast));
+        assert.equal(typeof methodEntryExitPoints, "object");
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "Identifier" && methodEntryExitPoints[node.name] && methodEntryExitPoints[node.name].entry) {
+                return {
+                    type: "CallExpression",
+                    callee: { type: "Identifier", name: "veilmark$bind" },
+                    arguments: [
+                        { type: "Identifier", name: "main" },
+                        { type: "Identifier", name: methodEntryExitPoints[node.name].entry }
+                    ]
+                };
+            }
+            return node;
+        });
+    }
+
+    /**
+     * Bumps all arguments indices like
+     * veilmark$arguments[0]
+     * to
+     * veilmark$arguments[1]
+     * @param {Function} method Function whose body will be transformed
+     * @param {number} inc Number to be added to all argument indices
+     */
+    bumpArgumentsIndices (method, inc) {
+        assert.ok(estest.isFunction(method));
+        assert.equal(typeof inc, "number");
+        
+        traverser.traverse(method.body, [], (node, stack) => {
+            if (node.type == "MemberExpression" && node.object.type == "Identifier" && node.object.name == "veilmark$arguments") {
+                node.property.value += inc;
+            }
+            if (node.veilmark$removeFirstArguments) {
+                node.value += inc;
+            }
+            return node;
+        });
+    }
+    
+};

package/processors/modules.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var assert = require("assert");
+var path = require("path");
+
+var _ = require("lodash");
+var escope = require("escope");
+
+var estest = require("../estest");
+var traverser = require("../traverser");
+var ESUtils = require("../esutils");
+var utils = require("../utils");
+
+/**
+ * Transform calls to require().
+ * @param {Node} node Root node
+ * @param {Function} processor Transformer
+ * @returns {Node} Root node
+ */
+function findRequires(node, processor) {
+    assert.ok(estest.isNode(node));
+    assert.equal(typeof processor, "function");
+    
+    return traverser.traverse(node, [], (node, stack) => {
+        if (node.type == "CallExpression" && node.callee.type == "Identifier" && node.callee.name == "require") {
+            return processor(node, stack);
+        } else {
+            return node;
+        }
+    });
+}
+
+/**
+ * Split path into parts.
+ * @param {string} path
+ * @returns {string[]}
+ */
+function splitPath(path) {
+    return path.split(/[\/\\]/g).filter(x => x != null && x.length > 0);
+}
+
+/**
+ * Normalize path.
+ * @param {string[]} path
+ * @returns {string}
+ */
+function normalizePath(path) {
+    var parts = splitPath(path);
+    
+    for (var i = parts.length - 1; i >= 0; --i) {
+        if (parts[i] == "" || parts[i] == ".") {
+            parts.splice(i, 1);
+        } else if (parts[i] == "..") {
+            parts.splice(i - 1, 2);
+        }
+    }
+    
+    return parts.join("/");
+}
+
+/**
+ * Get directory from path.
+ * @param {string} path
+ * @returns {string}
+ */
+function getPathDir(path) {
+    return splitPath(path).slice(0, -1).join("/");
+}
+
+/**
+ * Resolve path.
+ * TODO: This doesnt work as expected when path starts with a slash. Fix this.
+ * @param {string} curr Executing script
+ * @param {string} path Path
+ * @returns {string}
+ */
+function resolvePath(curr, path) {
+    return normalizePath(getPathDir(curr) + "/" + path);
+}
+
+module.exports = class Modules {
+
+    constructor (logger) {
+        this.logger = logger;
+        this.esutils = new ESUtils(logger);
+    }
+
+    /**
+     * Replace references to exports and module.exports.
+     * @param {Node} ast Root node
+     * @param {Node} replacement Replacement
+     * @returns {Node} Root node
+     */
+    replaceExportsReferences (ast, replacement) {
+        this.esutils.setParentsRecursive(ast);
+        
+        var scopeManager = escope.analyze(ast, { optimistic: true });
+        
+        scopeManager.scopes.forEach(scope => {
+            scope.references
+            .filter(reference => !utils.isResolvedReference(reference))
+            .forEach(reference => {
+                var parent = reference.identifier.veilmark$parent;
+                
+                if (reference.identifier.name == "exports") {
+                    this.esutils.replaceNode(ast, reference.identifier, utils.cloneISwearIKnowWhatImDoing(replacement));
+                } else if (
+                    parent.type == "MemberExpression"
+                    && (parent.object.type == "Identifier" && parent.object.name == "module")
+                    && ((parent.property.type == "Identifier" && parent.property.name == "exports") || (parent.property.type == "Literal" && parent.property.value == "exports"))
+                ) {
+                    this.esutils.replaceNode(ast, parent, utils.cloneISwearIKnowWhatImDoing(replacement));
+                }
+            });
+        });
+        
+        return ast;
+    }
+    
+    /**
+     * Merges multiple modules into a single main module.
+     * @param {Object.<string, Node>} modules Module dictionary
+     * @param {string} mainKey Main module key
+     * @param {ScopeManager} scopeManager Scope manager
+     * @returns {Node} Transformed root node
+     */
+    merge (modules, mainKey, scopeManager) {
+        assert.ok(Object.keys(modules).length > 0);
+        assert.equal(typeof mainKey, "string");
+        
+        modules = _.mapKeys(modules, (value, key) => normalizePath(key));
+        mainKey = normalizePath(mainKey);
+        
+        var declaration = {
+            type: "VariableDeclaration",
+            kind: "var",
+            declarations: []
+        };
+        var embeds = [];
+        
+        var rng = new utils.UniqueRandomAlpha(3);
+        
+        var processedModules = {};
+        
+        var requiresOrder = [];
+        
+        function walkDeps(key, stack) {
+            stack = stack || [];
+            
+            findRequires(modules[key], node => {
+                var path = node.arguments.length > 0 && node.arguments[0].value;
+
+                if (!path) {
+                    return node;
+                }
+                
+                if (![ "/", "./", "../" ].some(x => path.indexOf(x) == 0)) {
+                    return node;
+                }
+                
+                path = resolvePath(key, path);
+                
+                if (path.slice(-3) == ".js") {
+                    path = path.slice(0, -3);
+                }
+                
+                if (!modules[path]) {
+                    path = path + ".js";
+                }
+                
+                requiresOrder.push(path);
+                
+                var _module = modules[path];
+                if (!_module) {
+                    this.logger.warn(`Local module not found: ${path}`);
+                    return node;
+                }
+                
+                if (stack.indexOf(path) == -1) {
+                    walkDeps.call(this, path, stack.concat(path));
+                } else {
+                    this.logger.warn("Skipping cyclic depedency: " + path);
+                }
+                
+                if (!processedModules[path]) {
+                    var id = processedModules[path] = "$$module$" + rng.get();
+                
+                    declaration.declarations.push({
+                        type: "VariableDeclarator",
+                        id: { type: "Identifier", name: id },
+                        init: { type: "ObjectExpression", properties: [] }
+                    });
+                    
+                    _module = this.replaceExportsReferences(_module, { type: "Identifier", name: id });
+                    
+                    embeds.push({
+                        type: "ExpressionStatement",
+                        expression: {
+                            type: "CallExpression",
+                            callee: {
+                                type: "FunctionExpression",
+                                params: [
+                                ],
+                                body: {
+                                    type: "BlockStatement",
+                                    body: _module.body
+                                }
+                            },
+                            arguments: [
+                                
+                            ]
+                        },
+                        veilmark$module: path
+                    });
+                }
+                
+                return { type: "Identifier", name: processedModules[path] };
+            });
+        }
+        // Method has to be called via .call because otherwise this is not being passed correctly for some reason
+        walkDeps.call(this, mainKey);
+        
+        // Check whether the VariableDeclaration contains VariableDeclarators, because an empty VariableDeclaration causes errors
+        if (declaration.declarations.length > 0) {
+            modules[mainKey].body = [ declaration ].concat(embeds).concat(modules[mainKey].body);
+        }
+        
+        return modules[mainKey];
+    }
+
+};