js-confuser 1.5.9 → 1.7.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,7 +20,7 @@ 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 (

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

@@ -68,6 +68,8 @@ import Template from "../templates/template";
  * 3. using `this`
  */
 export default class Dispatcher extends Transform {
+  // Debug mode preserves function names
+  isDebug = false;
   count: number;
 
   constructor(o) {
@@ -124,6 +126,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 ||
@@ -136,8 +140,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);
@@ -196,14 +198,17 @@ export default class Dispatcher extends Transform {
         // map original name->new game
         var gen = this.getGenerator();
         Object.keys(functionDeclarations).forEach((name) => {
-          newFnNames[name] = gen.generate();
+          newFnNames[name] = this.isDebug
+            ? "_dispatcher_" + this.count + "_" + name
+            : gen.generate();
         });
         // set containing new name
         var set = new Set(Object.keys(newFnNames));
 
         // 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;

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(

package/src/transforms/es5/es5.ts

@@ -7,14 +7,10 @@ import {
   BlockStatement,
   ReturnStatement,
   CallExpression,
-  ObjectExpression,
-  ArrayExpression,
   ThisExpression,
-  Property,
 } from "../../util/gen";
-import { clone, getBlockBody, prepend } from "../../util/insert";
-import { isBlock, getBlock, walk } from "../../traverse";
-import Template from "../../templates/template";
+import { clone, prepend } from "../../util/insert";
+import { isBlock, walk } from "../../traverse";
 import { ObfuscateOrder } from "../../order";
 import { ok } from "assert";
 import { reservedKeywords } from "../../constants";
@@ -23,6 +19,7 @@ import AntiTemplate from "./antiTemplate";
 import AntiClass from "./antiClass";
 import AntiES6Object from "./antiES6Object";
 import AntiSpreadOperator from "./antiSpreadOperator";
+import { ES5Template } from "../../templates/es5";
 
 /**
  * `Const` and `Let` are not allowed in ES5.
@@ -96,24 +93,40 @@ export class AntiArrowFunction extends Transform {
   }
 }
 
-class FixedExpressions extends Transform {
+/**
+ * The ES5 options aims to convert ES6 and up features down to ES5-compatible code.
+ *
+ * The obfuscator regularly adds ES6 code (variable destructuring, spread element, etc.)
+ * This transformations goal is undo only these things.
+ */
+export default class ES5 extends Transform {
   constructor(o) {
-    super(o);
+    super(o, ObfuscateOrder.ES5);
+
+    this.before.push(new AntiClass(o));
+    this.before.push(new AntiTemplate(o));
+    this.before.push(new AntiSpreadOperator(o));
+    this.before.push(new AntiES6Object(o));
+    this.before.push(new AntiArrowFunction(o));
+    this.before.push(new AntiDestructuring(o));
+    this.before.push(new AntiConstLet(o));
   }
 
-  match(object, parents) {
-    return true;
+  apply(tree: Node) {
+    super.apply(tree);
+
+    var nodesToAdd = ES5Template.compile();
+    prepend(tree, ...nodesToAdd);
   }
 
-  transform(object, parents) {
-    return () => {
-      if (
-        object.type == "ForStatement" &&
-        object.init.type == "ExpressionStatement"
-      ) {
-        object.init = object.init.expression;
-      }
+  // FixedExpressions
+  match(object: Node, parents: Node[]) {
+    return !!object.type;
+  }
 
+  transform(object: Node, parents: Node[]) {
+    return () => {
+      // Object.keyword -> Object["keyword"]
       if (object.type == "MemberExpression") {
         if (!object.computed && object.property.type == "Identifier") {
           if (reservedKeywords.has(object.property.name)) {
@@ -123,6 +136,7 @@ class FixedExpressions extends Transform {
         }
       }
 
+      // { keyword: ... } -> { "keyword": ... }
       if (object.type == "Property") {
         if (!object.computed && object.key.type == "Identifier") {
           if (reservedKeywords.has(object.key.name)) {
@@ -133,62 +147,3 @@ class FixedExpressions extends Transform {
     };
   }
 }
-
-export default class ES5 extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.ES5);
-
-    this.before.push(new AntiClass(o));
-    this.before.push(new AntiTemplate(o));
-    this.before.push(new AntiSpreadOperator(o));
-    this.before.push(new AntiES6Object(o));
-    this.before.push(new AntiArrowFunction(o));
-    this.before.push(new AntiDestructuring(o));
-    this.before.push(new AntiConstLet(o));
-
-    this.concurrent.push(new FixedExpressions(o));
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.type == "Program";
-  }
-
-  transform(object: Node, parents: Node[]) {
-    var block = getBlock(object, parents);
-
-    getBlockBody(block).splice(
-      0,
-      0,
-      ...Template(`
-    !Array.prototype.forEach ? Array.prototype.forEach = function (callback, thisArg) {
-      thisArg = thisArg;
-      for (var i = 0; i < this.length; i++) {
-          callback.call(thisArg, this[i], i, this);
-      }
-    } : 0;
-  
-    !Array.prototype.map ? Array.prototype.map = function (callback, thisArg) {
-      thisArg = thisArg;
-      var array=[];
-      for (var i = 0; i < this.length; i++) {
-        array.push( callback.call(thisArg, this[i], i, this) );
-      }
-      return array;
-    } : 0;
-
-    !Array.prototype.reduce ? Array.prototype.reduce = function(fn, initial) {
-      var values = this;
-      if ( typeof initial === "undefined" ) {
-        initial = 0;
-      }
-
-      values.forEach(function(item, index){
-        initial = fn(initial, item, index, this);
-      });
-
-      return initial;
-    } : 0;
-  `).compile()
-    );
-  }
-}