js-confuser 1.5.8 → 1.6.0

package/src/transforms/controlFlowFlattening/expressionObfuscation.ts

@@ -2,6 +2,9 @@ import { isBlock } from "../../traverse";
 import { Identifier, SequenceExpression } from "../../util/gen";
 import Transform from "../transform";
 
+/**
+ * Expression Obfuscation runs before Control Flow Flattening
+ */
 export default class ExpressionObfuscation extends Transform {
   constructor(o) {
     super(o);
@@ -17,10 +20,16 @@ export default class ExpressionObfuscation extends Transform {
       var deleteExprs = [];
 
       object.body.forEach((stmt, i) => {
-        if (stmt.type == "ExpressionStatement") {
+        if (stmt.type == "ExpressionStatement" && !stmt.directive) {
           var expr = stmt.expression;
 
-          if (expr.type == "UnaryExpression" && exprs.length) {
+          if (
+            expr.type == "UnaryExpression" &&
+            !(
+              expr.operator === "typeof" && expr.argument.type === "Identifier"
+            ) &&
+            exprs.length // typeof is special
+          ) {
             expr.argument = SequenceExpression([
               ...exprs,
               { ...expr.argument },
@@ -38,7 +47,13 @@ export default class ExpressionObfuscation extends Transform {
                 stmt.test.type == "BinaryExpression" &&
                 stmt.test.operator !== "**"
               ) {
-                if (stmt.test.left.type == "UnaryExpression") {
+                if (
+                  stmt.test.left.type == "UnaryExpression" &&
+                  !(
+                    stmt.test.left.operator === "typeof" &&
+                    stmt.test.left.argument.type === "Identifier"
+                  ) // typeof is special
+                ) {
                   stmt.test.left.argument = SequenceExpression([
                     ...exprs,
                     { ...stmt.test.left.argument },

package/src/transforms/deadCode.ts

@@ -226,6 +226,356 @@ function setCookie(cname, cvalue, exdays) {
     getHeightBalanced,
   };
   `),
+  Template(`
+  function ListNode(){}
+  var addTwoNumbers = function(l1, l2) {
+    var carry = 0;
+    var sum = 0;
+    var head = new ListNode(0);
+    var now = head;
+    var a = l1;
+    var b = l2;
+    while (a !== null || b !== null) {
+      sum = (a ? a.val : 0) + (b ? b.val : 0) + carry;
+      carry = Math.floor(sum / 10);
+      now.next = new ListNode(sum % 10);
+      now = now.next;
+      a = a ? a.next : null;
+      b = b ? b.next : null;
+    }
+    if (carry) now.next = new ListNode(carry);
+    return head.next;
+  };
+
+  console.log(addTwoNumbers)
+  `),
+  Template(`
+  var threeSum = function(nums) {
+    var len = nums.length;
+    var res = [];
+    var l = 0;
+    var r = 0;
+    nums.sort((a, b) => (a - b));
+    for (var i = 0; i < len; i++) {
+      if (i > 0 && nums[i] === nums[i - 1]) continue;
+      l = i + 1;
+      r = len - 1;
+      while (l < r) {
+        if (nums[i] + nums[l] + nums[r] < 0) {
+          l++;
+        } else if (nums[i] + nums[l] + nums[r] > 0) {
+          r--;
+        } else {
+          res.push([nums[i], nums[l], nums[r]]);
+          while (l < r && nums[l] === nums[l + 1]) l++;
+          while (l < r && nums[r] === nums[r - 1]) r--;
+          l++;
+          r--;
+        }
+      }
+    }
+    return res;
+  };
+  console.log(threeSum)
+  `),
+  Template(`
+  var combinationSum2 = function(candidates, target) {
+    var res = [];
+    var len = candidates.length;
+    candidates.sort((a, b) => (a - b));
+    dfs(res, [], 0, len, candidates, target);
+    return res;
+  };
+
+  var dfs = function (res, stack, index, len, candidates, target) {
+    var tmp = null;
+    if (target < 0) return;
+    if (target === 0) return res.push(stack);
+    for (var i = index; i < len; i++) {
+      if (candidates[i] > target) break;
+      if (i > index && candidates[i] === candidates[i - 1]) continue;
+      tmp = Array.from(stack);
+      tmp.push(candidates[i]);
+      dfs(res, tmp, i + 1, len, candidates, target - candidates[i]);
+    }
+  };
+
+  console.log(combinationSum2);
+  `),
+  Template(`
+  var isScramble = function(s1, s2) {
+    return helper({}, s1, s2);
+  };
+  
+  var helper = function (dp, s1, s2) {
+    var map = {};
+  
+    if (dp[s1 + s2] !== undefined) return dp[s1 + s2];
+    if (s1 === s2) return true;
+  
+    for (var j = 0; j < s1.length; j++) {
+      if (map[s1[j]] === undefined) map[s1[j]] = 0;
+      if (map[s2[j]] === undefined) map[s2[j]] = 0;
+      map[s1[j]]++;
+      map[s2[j]]--;
+    }
+  
+    for (var key in map) {
+      if (map[key] !== 0) {
+        dp[s1 + s2] = false;
+        return false;
+      }
+    }
+  
+    for (var i = 1; i < s1.length; i++) {
+      if ((helper(dp, s1.substr(0, i), s2.substr(0, i))
+           && helper(dp, s1.substr(i), s2.substr(i))) ||
+          (helper(dp, s1.substr(0, i), s2.substr(s2.length - i))
+           && helper(dp, s1.substr(i), s2.substr(0, s2.length - i)))) {
+        dp[s1 + s2] = true;
+        return true;
+      }
+    }
+  
+    dp[s1 + s2] = false;
+    return false;
+  };
+
+  console.log(isScramble);
+  `),
+  Template(`
+  var candy = function(ratings) {
+    var len = ratings.length;
+    var res = [];
+    var sum = 0;
+    for (var i = 0; i < len; i++) {
+      res.push((i !== 0 && ratings[i] > ratings[i - 1]) ? (res[i - 1] + 1) : 1);
+    }
+    for (var j = len - 1; j >= 0; j--) {
+      if (j !== len - 1 && ratings[j] > ratings[j + 1]) res[j] = Math.max(res[j], res[j + 1] + 1);
+      sum += res[j];
+    }
+    return sum;
+  };
+  
+  console.log(candy)
+  `),
+  Template(`
+  var maxPoints = function(points) {
+    var max = 0;
+    var map = {};
+    var localMax = 0;
+    var samePoint = 0;
+    var k = 0;
+    var len = points.length;
+    for (var i = 0; i < len; i++) {
+      map = {};
+      localMax = 0;
+      samePoint = 1;
+      for (var j = i + 1; j < len; j++) {
+        if (points[i].x === points[j].x && points[i].y === points[j].y) {
+          samePoint++;
+          continue;
+        }
+          if (points[i].y === points[j].y) k = Number.MAX_SAFE_INTEGER;
+          else k = (points[i].x - points[j].x) / (points[i].y - points[j].y);
+          if (!map[k]) map[k] = 0;
+          map[k]++;
+          localMax = Math.max(localMax, map[k]);
+      }
+      localMax += samePoint;
+      max = Math.max(max, localMax);
+    }
+    return max;
+  };
+  
+  console.log(maxPoints)
+  `),
+  Template(`
+  var maximumGap = function(nums) {
+    var len = nums.length;
+    if (len < 2) return 0;
+  
+    var max = Math.max(...nums);
+    var min = Math.min(...nums);
+    if (max === min) return 0;
+  
+    var minBuckets = Array(len - 1).fill(Number.MAX_SAFE_INTEGER);
+    var maxBuckets = Array(len - 1).fill(Number.MIN_SAFE_INTEGER);
+    var gap = Math.ceil((max - min) / (len - 1));
+    var index = 0;
+    for (var i = 0; i < len; i++) {
+      if (nums[i] === min || nums[i] === max) continue;
+      index = Math.floor((nums[i] - min) / gap);
+      minBuckets[index] = Math.min(minBuckets[index], nums[i]);
+      maxBuckets[index] = Math.max(maxBuckets[index], nums[i]);
+    }
+  
+    var maxGap = Number.MIN_SAFE_INTEGER;
+    var preVal = min;
+    for (var j = 0; j < len - 1; j++) {
+      if (minBuckets[j] === Number.MAX_SAFE_INTEGER && maxBuckets[j] === Number.MIN_SAFE_INTEGER) continue;
+      maxGap = Math.max(maxGap, minBuckets[j] - preVal);
+      preVal = maxBuckets[j];
+    }
+    maxGap = Math.max(maxGap, max - preVal);
+  
+    return maxGap;
+  };
+
+  console.log(maximumGap);
+  `),
+  Template(`
+  /**
+   * @param {number} capacity
+   */
+  var LRUCache = function(capacity) {
+    this.capacity = capacity;
+    this.length = 0;
+    this.map = {};
+    this.head = null;
+    this.tail = null;
+  };
+  
+  /** 
+   * @param {number} key
+   * @return {number}
+   */
+  LRUCache.prototype.get = function(key) {
+    var node = this.map[key];
+    if (node) {
+      this.remove(node);
+      this.insert(node.key, node.val);
+      return node.val;
+    } else {
+      return -1;
+    }
+  };
+  
+  /** 
+   * @param {number} key 
+   * @param {number} value
+   * @return {void}
+   */
+  LRUCache.prototype.put = function(key, value) {
+    if (this.map[key]) {
+      this.remove(this.map[key]);
+      this.insert(key, value);
+    } else {
+      if (this.length === this.capacity) {
+        this.remove(this.head);
+        this.insert(key, value);
+      } else {
+        this.insert(key, value);
+        this.length++;
+      }
+    }
+  };
+  
+  /** 
+   * Your LRUCache object will be instantiated and called as such:
+   * var obj = Object.create(LRUCache).createNew(capacity)
+   * var param_1 = obj.get(key)
+   * obj.put(key,value)
+   */
+  
+  LRUCache.prototype.remove = function (node) {
+    var prev = node.prev;
+    var next = node.next;
+    if (next) next.prev = prev;
+    if (prev) prev.next = next;
+    if (this.head === node) this.head = next;
+    if (this.tail === node) this.tail = prev;
+    delete this.map[node.key];
+  };
+  
+  LRUCache.prototype.insert = function (key, val) {
+    var node = new List(key, val);
+    if (!this.tail) {
+      this.tail = node;
+      this.head = node;
+    } else {
+      this.tail.next = node;
+      node.prev = this.tail;
+      this.tail = node;
+    }
+    this.map[key] = node;
+  };
+
+  console.log(LRUCache);
+  `),
+  Template(`
+  var isInterleave = function(s1, s2, s3) {
+    var dp = {};
+    if (s3.length !== s1.length + s2.length) return false;
+    return helper(s1, s2, s3, 0, 0, 0, dp);
+  };
+  
+  var helper = function (s1, s2, s3, i, j, k, dp) {
+    var res = false;
+  
+    if (k >= s3.length) return true;
+    if (dp['' + i + j + k] !== undefined) return dp['' + i + j + k];
+  
+    if (s3[k] === s1[i] && s3[k] === s2[j]) {
+      res = helper(s1, s2, s3, i + 1, j, k + 1, dp) || helper(s1, s2, s3, i, j + 1, k + 1, dp);
+    } else if (s3[k] === s1[i]) {
+      res = helper(s1, s2, s3, i + 1, j, k + 1, dp);
+    } else if (s3[k] === s2[j]) {
+      res = helper(s1, s2, s3, i, j + 1, k + 1, dp);
+    }
+  
+    dp['' + i + j + k] = res;
+  
+    return res;
+  };
+
+  console.log(isInterleave);
+  `),
+  Template(`
+  var solveNQueens = function(n) {
+    var res = [];
+    if (n === 1 || n >= 4) dfs(res, [], n, 0);
+    return res;
+  };
+  
+  var dfs = function (res, points, n, index) {
+    for (var i = index; i < n; i++) {
+      if (points.length !== i) return;
+      for (var j = 0; j < n; j++) {
+        if (isValid(points, [i, j])) {
+          points.push([i, j]);
+          dfs(res, points, n, i + 1);
+          if (points.length === n) res.push(buildRes(points));
+          points.pop();
+        }
+      }
+    }
+  };
+  
+  var buildRes = function (points) {
+    var res = [];
+    var n = points.length;
+    for (var i = 0; i < n; i++) {
+      res[i] = '';
+      for (var j = 0; j < n; j++) {
+        res[i] += (points[i][1] === j ? 'Q' : '.');
+      }
+    }
+    return res;
+  };
+  
+  var isValid = function (oldPoints, newPoint) {
+    var len = oldPoints.length;
+    for (var i = 0; i < len; i++) {
+      if (oldPoints[i][0] === newPoint[0] || oldPoints[i][1] === newPoint[1]) return false;
+      if (Math.abs((oldPoints[i][0] - newPoint[0]) / (oldPoints[i][1] - newPoint[1])) === 1) return false;
+    }
+    return true;
+  };
+
+  console.log(solveNQueens);
+  `),
 ];
 
 /**
@@ -235,7 +585,6 @@ function setCookie(cname, cvalue, exdays) {
  * - Adds fake code from various samples.
  */
 export default class DeadCode extends Transform {
-  usedNames: Set<string>;
   made: number;
 
   constructor(o) {
@@ -253,35 +602,43 @@ export default class DeadCode extends Transform {
   }
 
   transform(object: Node, parents: Node[]) {
-    if (ComputeProbabilityMap(this.options.deadCode)) {
-      return () => {
-        this.made++;
-        if (this.made > 100) {
-          return;
-        }
+    if (!ComputeProbabilityMap(this.options.deadCode)) {
+      return;
+    }
 
-        var name = this.getPlaceholder();
-        var variableDeclaration = VariableDeclaration(
-          VariableDeclarator(name, Literal(false))
-        );
+    // Hard-coded limit of 100 Dead Code insertions
+    this.made++;
+    if (this.made > 100) {
+      return;
+    }
+
+    return () => {
+      var body = getBlockBody(object);
 
-        var body = getBlockBody(object);
-        var index = getRandomInteger(0, body.length);
+      // Do not place code before Import statements or 'use strict' directives
+      var safeOffset = 0;
+      for (var node of body) {
+        if (node.type === "ImportDeclaration" || node.directive) safeOffset++;
+        else break;
+      }
 
-        var template;
-        do {
-          template = choice(templates);
-        } while (this.options.es5 && template.source.includes("async"));
+      var index = getRandomInteger(safeOffset, body.length);
 
-        var ifStatement = IfStatement(
-          Identifier(name),
-          template.compile(),
-          null
-        );
+      var name = this.getPlaceholder();
+      var variableDeclaration = VariableDeclaration(
+        VariableDeclarator(name, Literal(false))
+      );
 
-        body.splice(index, 0, ifStatement);
-        prepend(object, variableDeclaration);
-      };
-    }
+      var template;
+      do {
+        template = choice(templates);
+      } while (this.options.es5 && template.source.includes("async"));
+
+      var ifStatement = IfStatement(Identifier(name), template.compile(), null);
+
+      body.splice(index, 0, ifStatement);
+
+      prepend(object, variableDeclaration);
+    };
   }
 }

package/src/transforms/dispatcher.ts

@@ -97,14 +97,15 @@ export default class Dispatcher extends Transform {
         }
 
         // Map of FunctionDeclarations
-        var functionDeclarations: { [name: string]: Location } = {};
+        var functionDeclarations: { [name: string]: Location } =
+          Object.create(null);
 
         // Array of Identifier nodes
         var identifiers: Location[] = [];
         var illegalFnNames: Set<string> = new Set();
 
         // New Names for Functions
-        var newFnNames: { [name: string]: string } = {}; // [old name]: randomized name
+        var newFnNames: { [name: string]: string } = Object.create(null); // [old name]: randomized name
 
         var context = isVarContext(object)
           ? object
@@ -123,6 +124,8 @@ export default class Dispatcher extends Transform {
 
           if (context === c) {
             if (o.type == "FunctionDeclaration" && o.id.name) {
+              var name = o.id.name;
+
               if (
                 o.$requiresEval ||
                 o.async ||
@@ -135,8 +138,6 @@ export default class Dispatcher extends Transform {
                 illegalFnNames.add(name);
               }
 
-              var name = o.id.name;
-
               // If dupe, no routing
               if (functionDeclarations[name]) {
                 illegalFnNames.add(name);
@@ -202,7 +203,8 @@ export default class Dispatcher extends Transform {
 
         // Only make a dispatcher function if it caught any functions
         if (set.size > 0) {
-          var payloadArg = `$jsc_d${this.count}_payload`;
+          var payloadArg =
+            this.getPlaceholder() + "_dispatcher_" + this.count + "_payload";
 
           var dispatcherFnName =
             this.getPlaceholder() + "_dispatcher_" + this.count;
@@ -469,7 +471,7 @@ export default class Dispatcher extends Transform {
             }
 
             var newName = newFnNames[o.name];
-            if (!newName) {
+            if (!newName || typeof newName !== "string") {
               return;
             }
 

package/src/transforms/es5/antiClass.ts

@@ -110,7 +110,16 @@ export default class AntiClass extends Transform {
           );
         }
 
-        if (
+        // Support class fields
+        if (methodDefinition.type === "PropertyDefinition") {
+          var assignmentExpression = AssignmentExpression(
+            "=",
+            key,
+            value || Identifier("undefined")
+          );
+
+          pushingTo.push(ExpressionStatement(assignmentExpression));
+        } else if (
           methodDefinition.kind == "constructor" ||
           methodDefinition.kind == "method"
         ) {

package/src/transforms/es5/antiDestructuring.ts

@@ -211,6 +211,8 @@ export default class AntiDestructuring extends Transform {
           exprs.push(AssignmentExpression(operator, clone(x), realm));
 
           names.add(x.name);
+        } else if (x.type == "MemberExpression") {
+          exprs.push(AssignmentExpression(operator, clone(x), realm));
         } else if (x.type == "ObjectPattern") {
           x.properties.forEach((property) => {
             recursive(
@@ -266,7 +268,7 @@ export default class AntiDestructuring extends Transform {
         ]);
 
         if (object.type == "VariableDeclarator") {
-          var i = getIndexDirect(object, parents);
+          var i = getIndexDirect(object, parents[0]);
 
           var extra = Array.from(names).map((x) => {
             return {