@dacely/toildefender 0.1.5 → 0.1.7

package/processors/uglifier.js

@@ -3,8 +3,222 @@
 var assert = require("assert");
 
 var esshorten = require("esshorten");
+var escope = require("escope");
 
 var estest = require("../estest");
+var traverser = require("../traverser");
+
+var RESERVED_WORDS = new Set([
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "arguments",
+    "undefined"
+]);
+
+var FIRST_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
+var REST_CHARS = FIRST_CHARS + "0123456789";
+
+function containsModernBindings(ast) {
+    var found = false;
+    traverser.traverseEx(ast, [], function (node) {
+        if (
+            (node.type == "VariableDeclaration" && node.kind != "var")
+            || node.type == "ClassDeclaration"
+            || node.type == "ClassExpression"
+        ) {
+            found = true;
+            this.abort();
+        }
+        return node;
+    });
+    return found;
+}
+
+function shortName(index) {
+    var name = FIRST_CHARS[index % FIRST_CHARS.length];
+    index = Math.floor(index / FIRST_CHARS.length);
+    while (index > 0) {
+        index -= 1;
+        name += REST_CHARS[index % REST_CHARS.length];
+        index = Math.floor(index / REST_CHARS.length);
+    }
+    return name;
+}
+
+function collectUnresolvedNames(scopeManager) {
+    var names = new Set();
+    scopeManager.scopes.forEach(scope => {
+        scope.through.forEach(reference => {
+            if (!reference.resolved) {
+                names.add(reference.identifier.name);
+            }
+        });
+    });
+    return names;
+}
+
+function isRenamableVariable(scope, variable, unresolvedNames) {
+    if (scope.type == "global") {
+        return false;
+    }
+    if (
+        typeof variable.name == "string"
+        && variable.name.indexOf("toildefender$anon$") === 0
+        && unresolvedNames.has(variable.name)
+    ) {
+        return false;
+    }
+    if (variable.name == "arguments" || variable.name == "undefined") {
+        return false;
+    }
+    if (variable.tainted) {
+        return false;
+    }
+    if (!variable.identifiers || variable.identifiers.length == 0) {
+        return false;
+    }
+    if (variable.defs && variable.defs.some(def => def.type == "ClassName")) {
+        return false;
+    }
+    return true;
+}
+
+function reserveUnrenamedNames(scopeManager, renamable) {
+    var reserved = new Set(RESERVED_WORDS);
+    scopeManager.scopes.forEach(scope => {
+        scope.variables.forEach(variable => {
+            if (!renamable.has(variable)) {
+                reserved.add(variable.name);
+            }
+        });
+        scope.through.forEach(reference => {
+            if (!reference.resolved) {
+                reserved.add(reference.identifier.name);
+            }
+        });
+    });
+    return reserved;
+}
+
+function buildParentMap(ast) {
+    var parents = new WeakMap();
+    traverser.traverse(ast, [], function (node, stack) {
+        var parentFrame = stack[1];
+        if (parentFrame) {
+            parents.set(node, parentFrame.node);
+        }
+        return node;
+    });
+    return parents;
+}
+
+function renameIdentifier(identifier, name, parents) {
+    var parent = parents.get(identifier);
+    if (
+        parent
+        && parent.type == "Property"
+        && parent.shorthand === true
+        && (parent.key === identifier || parent.value === identifier)
+    ) {
+        parent.shorthand = false;
+        parent.key = {
+            type: "Identifier",
+            name: identifier.name
+        };
+        parent.value = {
+            type: "Identifier",
+            name: name
+        };
+        parents.set(parent.key, parent);
+        parents.set(parent.value, parent);
+        return;
+    }
+
+    identifier.name = name;
+}
+
+function modernMangle(ast) {
+    var scopeManager = escope.analyze(ast, {
+        ecmaVersion: 6,
+        optimistic: true,
+        sourceType: "script"
+    });
+
+    var unresolvedNames = collectUnresolvedNames(scopeManager);
+    var variables = [];
+    scopeManager.scopes.forEach(scope => {
+        scope.variables.forEach(variable => {
+            if (isRenamableVariable(scope, variable, unresolvedNames)) {
+                variables.push({ scope: scope, variable: variable });
+            }
+        });
+    });
+
+    variables.sort((left, right) => {
+        var leftWeight = left.variable.references.length + left.variable.identifiers.length;
+        var rightWeight = right.variable.references.length + right.variable.identifiers.length;
+        return rightWeight - leftWeight;
+    });
+
+    var renamable = new Set(variables.map(entry => entry.variable));
+    var used = reserveUnrenamedNames(scopeManager, renamable);
+    var parents = buildParentMap(ast);
+    var next = 0;
+
+    variables.forEach(entry => {
+        var name;
+        do {
+            name = shortName(next);
+            next += 1;
+        } while (used.has(name) || RESERVED_WORDS.has(name));
+        used.add(name);
+
+        entry.variable.identifiers.forEach(identifier => {
+            renameIdentifier(identifier, name, parents);
+        });
+        entry.variable.references.forEach(reference => {
+            renameIdentifier(reference.identifier, name, parents);
+        });
+    });
+
+    return ast;
+}
 
 module.exports = class Uglifier {
 
@@ -19,8 +233,11 @@ module.exports = class Uglifier {
      */
     uglify (ast) {
         assert.ok(estest.isNode(ast));
-        
+
+        if (containsModernBindings(ast)) {
+            return modernMangle(ast);
+        }
         return esshorten.mangle(ast);
     }
 
-};
+};

package/processors/variables.js

@@ -72,11 +72,29 @@ function isClassMethodScope(scope) {
         if (node.type == "MethodDefinition" || node.type == "ClassBody") {
             return true;
         }
-        node = node.veilmark$parent;
+        node = node.toildefender$parent;
     }
     return false;
 }
 
+function isNumericVmInternalNode(node) {
+    while (node) {
+        if (node.toildefender$numericVmInternal === true) {
+            return true;
+        }
+        node = node.toildefender$parent;
+    }
+    return false;
+}
+
+function isNumericVmInternalScope(scope) {
+    return isNumericVmInternalNode(scope && scope.block);
+}
+
+function isNumericVmInternalVariable(variable) {
+    return variable.defs.some(def => isNumericVmInternalNode(def.node));
+}
+
 module.exports = class Variables {
 
     constructor (logger) {
@@ -93,6 +111,9 @@ module.exports = class Variables {
      */
     removeFunctionExpressionIds (ast) {
         return traverser.traverse(ast, [], (node, stack) => {
+            if (isNumericVmInternalNode(node)) {
+                return node;
+            }
             if (node.type == "FunctionExpression" && node.id && !functionExpressionUsesOwnName(node)) {
                 node.id = null;
             }
@@ -114,7 +135,7 @@ module.exports = class Variables {
         this.esutils.setParentsRecursive(ast);
         
         scopeManager.scopes.forEach(scope => {
-            if (!this.esutils.canInsertIntoScope(scope) || isClassMethodScope(scope)) {
+            if (!this.esutils.canInsertIntoScope(scope) || isClassMethodScope(scope) || isNumericVmInternalScope(scope)) {
                 return;
             }
             scope.variables.forEach(variable => {
@@ -127,7 +148,7 @@ module.exports = class Variables {
                          * as a FunctionExpression with an id, which are then
                          * mistakingly replaced with EmptyStatements.
                          */
-                        if (estest.isStatement(def.node)) {
+                        if (estest.isStatement(def.node) && !isNumericVmInternalNode(def.node)) {
                             this.esutils.replaceNode(ast, def.node, { type: "EmptyStatement" });
                             this.esutils.insertIntoScope(scope, {
                                 type: "VariableDeclaration",
@@ -142,7 +163,8 @@ module.exports = class Variables {
                                             body: def.node.body,
                                             generator: def.node.generator === true,
                                             expression: def.node.expression === true,
-                                            async: def.node.async === true
+                                            async: def.node.async === true,
+                                            toildefender$numericVmInternal: def.node.toildefender$numericVmInternal === true
                                         }
                                     }
                                 ]
@@ -163,8 +185,22 @@ module.exports = class Variables {
      * @param {ScopeManager} scopeManager Scope manager
      */
     obfuscateIdentifiers (ast, scopeManager) {
+        var usedNames = new Set();
+
+        function uniqueName(variable) {
+            var base = "$$var$" + utils.hash(variable);
+            var name = base + "$" + variable.name;
+            var counter = 0;
+            while (usedNames.has(name)) {
+                counter += 1;
+                name = base + counter.toString(36) + "$" + variable.name;
+            }
+            usedNames.add(name);
+            return name;
+        }
+
         scopeManager.scopes.forEach(scope => {
-            if (isClassMethodScope(scope)) {
+            if (isClassMethodScope(scope) || isNumericVmInternalScope(scope)) {
                 return;
             }
             if (scope.isStatic()) {
@@ -179,7 +215,11 @@ module.exports = class Variables {
                 });
 
                 for (let variable of scope.variables) {
-                    var name = "$$var$" + utils.hash(variable) + "$" + variable.name;
+                    if (isNumericVmInternalVariable(variable)) {
+                        continue;
+                    }
+
+                    var name = uniqueName(variable);
 
                     if (variable.defs.some(def => def.type == "ClassName")) {
                         continue;
@@ -199,7 +239,7 @@ module.exports = class Variables {
                         def.name = name;
                     }
 
-                    for (let ref of variable.references) {
+                    for (let ref of variable.references.filter(ref => ref.resolved === variable)) {
                         // change reference's name
                         ref.identifier.name = name;
                     }
@@ -236,10 +276,13 @@ module.exports = class Variables {
         var rng = new utils.UniqueRandomAlpha(3);
         
         scopeManager.scopes.forEach(scope => {
-            if (!this.esutils.canInsertIntoScope(scope) || isClassMethodScope(scope)) {
+            if (!this.esutils.canInsertIntoScope(scope) || isClassMethodScope(scope) || isNumericVmInternalScope(scope)) {
                 return;
             }
             scope.variables.forEach(variable => {
+                if (isNumericVmInternalVariable(variable)) {
+                    return;
+                }
                 variable.defs.forEach(def => {
                     if (def.type == "Parameter") {
                         assert(def.name.type == "Identifier");