js-confuser 1.6.0 → 1.7.0

package/test/transforms/stack.test.ts

@@ -519,3 +519,55 @@ test("Variant #16: Function with 'this'", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual(true);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/88
+test("Variant #17: Syncing arguments parameter", async () => {
+  var output = await JsConfuser(
+    `
+    var TEST_OUTPUT;
+
+    function syncingArguments(parameter) {
+      arguments[0] = "Correct Value";
+      TEST_OUTPUT = parameter;
+    }
+    
+    syncingArguments("Incorrect Value");
+  `,
+    { target: "node", stack: true }
+  );
+
+  function evalNoStrictMode(evalCode) {
+    var fn = new Function(evalCode + ";return TEST_OUTPUT");
+    return fn();
+  }
+
+  var TEST_OUTPUT = evalNoStrictMode(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});
+
+test("Variant #18: Preserve function.length property", async () => {
+  var output = await JsConfuser(
+    `
+    function oneParameter(a){
+      var _ = 1;
+    };
+    var twoParameters = function(a,b){
+      var _ = 1;
+    };
+    var myObject = {
+      threeParameters(a,b,c){
+        var _ = 1;
+      }
+    }
+
+    TEST_OUTPUT = oneParameter.length + twoParameters.length + myObject.threeParameters.length;
+  `,
+    { target: "node", stack: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(6);
+});

package/test/util/identifiers.test.ts

@@ -1,4 +1,7 @@
-import parseJS from "../../src/parser";
+import { ok } from "assert";
+import parseJS, { parseSync } from "../../src/parser";
+import traverse from "../../src/traverse";
+import { Location, Node } from "../../src/util/gen";
 import {
   getFunctionParameters,
   getIdentifierInfo,
@@ -41,6 +44,115 @@ describe("getIdentifierInfo", () => {
       getIdentifierInfo({ type: "Literal", value: true }, []);
     }).toThrow();
   });
+
+  function findIdentifier(tree: Node, identifierName: string) {
+    var searchLocation: Location;
+
+    traverse(tree, (o, p) => {
+      if (o.type === "Identifier" && o.name === identifierName) {
+        ok(!searchLocation);
+        searchLocation = [o, p];
+      }
+    });
+
+    ok(searchLocation);
+    return searchLocation;
+  }
+
+  test("Variant #4: Variable declaration assignment pattern", async () => {
+    var tree = parseSync(`
+      var [ definedIdentifier = nonDefinedIdentifier ] = [];
+    `);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
+  });
+
+  test("Variant #5: Function parameter assignment pattern", async () => {
+    var tree = parseSync(`
+      function myFunction(definedIdentifier = nonDefinedIdentifier) {
+
+      }
+    `);
+
+    var myFunction = findIdentifier(tree, "myFunction");
+    var myFunctionInfo = getIdentifierInfo(myFunction[0], myFunction[1]);
+
+    expect(myFunctionInfo.isFunctionDeclaration).toStrictEqual(true);
+    expect(myFunctionInfo.spec.isDefined).toStrictEqual(true);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
+  });
+
+  test("Variant #6: Object pattern", async () => {
+    var tree = parseSync(`
+      var { nonDefinedIdentifier: definedIdentifier } = {};
+
+      ( { nonModifiedIdentifier: modifiedIdentifier } = {} );
+    `);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(false);
+
+    var modifiedIdentifier = findIdentifier(tree, "modifiedIdentifier");
+    var modifiedInfo = getIdentifierInfo(
+      modifiedIdentifier[0],
+      modifiedIdentifier[1]
+    );
+    expect(modifiedInfo.spec.isDefined).toStrictEqual(false);
+    expect(modifiedInfo.spec.isModified).toStrictEqual(true);
+    expect(modifiedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonModifiedIdentifier = findIdentifier(tree, "nonModifiedIdentifier");
+    var nonModifiedInfo = getIdentifierInfo(
+      nonModifiedIdentifier[0],
+      nonModifiedIdentifier[1]
+    );
+
+    expect(nonModifiedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonModifiedInfo.spec.isModified).toStrictEqual(false);
+    expect(nonModifiedInfo.spec.isReferenced).toStrictEqual(false);
+  });
 });
 
 describe("validateChain", () => {

package/test/util/insert.test.ts

@@ -1,7 +1,8 @@
+import { ok } from "assert";
 import { compileJsSync } from "../../src/compiler";
-import parseJS from "../../src/parser";
-import { isBlock } from "../../src/traverse";
-import { Identifier } from "../../src/util/gen";
+import parseJS, { parseSync } from "../../src/parser";
+import traverse, { isBlock } from "../../src/traverse";
+import { Identifier, Location } from "../../src/util/gen";
 import {
   deleteDeclaration,
   isVarContext,
@@ -10,6 +11,7 @@ import {
   getContexts,
   getLexContext,
   getVarContext,
+  computeFunctionLength,
 } from "../../src/util/insert";
 
 it("isBlock() should be true for block statements and program", async () => {
@@ -86,3 +88,55 @@ it("should throw when missing parameters", () => {
   expect(() => getLexContext(Identifier("test"), [])).toThrow();
   expect(() => getVarContext(Identifier("test"), [])).toThrow();
 });
+
+test("computeFunctionLength", () => {
+  var tree = parseSync(`
+  function zeroParameters(){}; // 0
+  function oneParameter(a){}; // 1
+  function twoParameter(a,b){}; // 2
+  function restParameter1(...a){}; // 0
+  function restParameter2(a,b,...c){}; // 2
+  function defaultValue(a,b,c=1,d){}; // 2
+  function arrayPattern([a],[b = 2],[[c]]){}; // 3
+  function objectPattern({a},{b = 2},{c, d}){}; // 3
+  function mixed(a,{b},[c = 3],d,e=5,f,...g){}; // 4
+  `);
+
+  function getFunction(searchName: string): Location {
+    var searchLocation: Location;
+    traverse(tree, (o, p) => {
+      if (o.type === "FunctionDeclaration" && o.id.name === searchName) {
+        ok(!searchLocation);
+        searchLocation = [o, p];
+      }
+    });
+
+    ok(searchLocation);
+    return searchLocation;
+  }
+
+  expect(
+    computeFunctionLength(getFunction("zeroParameters")[0].params)
+  ).toStrictEqual(0);
+  expect(
+    computeFunctionLength(getFunction("oneParameter")[0].params)
+  ).toStrictEqual(1);
+  expect(
+    computeFunctionLength(getFunction("twoParameter")[0].params)
+  ).toStrictEqual(2);
+  expect(
+    computeFunctionLength(getFunction("restParameter1")[0].params)
+  ).toStrictEqual(0);
+  expect(
+    computeFunctionLength(getFunction("restParameter2")[0].params)
+  ).toStrictEqual(2);
+  expect(
+    computeFunctionLength(getFunction("arrayPattern")[0].params)
+  ).toStrictEqual(3);
+  expect(
+    computeFunctionLength(getFunction("objectPattern")[0].params)
+  ).toStrictEqual(3);
+  expect(computeFunctionLength(getFunction("mixed")[0].params)).toStrictEqual(
+    4
+  );
+});

package/src/transforms/eval.ts

@@ -1,89 +0,0 @@
-import { compileJsSync } from "../compiler";
-import { ObfuscateOrder } from "../order";
-import { ComputeProbabilityMap } from "../probability";
-import { isBlock } from "../traverse";
-import {
-  CallExpression,
-  Identifier,
-  Literal,
-  Node,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../util/gen";
-import { isFunction, prepend } from "../util/insert";
-import Transform from "./transform";
-
-export default class Eval extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.Eval);
-  }
-
-  match(object, parents) {
-    return (
-      isFunction(object) &&
-      object.type != "ArrowFunctionExpression" &&
-      !object.$eval &&
-      !object.$dispatcherSkip
-    );
-  }
-
-  transform(object, parents) {
-    // Don't apply to getter/setters or class methods
-    if (parents[0]) {
-      if (
-        parents[0].type === "MethodDefinition" &&
-        parents[0].value === object
-      ) {
-        return;
-      }
-
-      if (
-        parents[0].type === "Property" &&
-        parents[0].value === object &&
-        (parents[0].kind !== "init" || parents[0].method)
-      ) {
-        return;
-      }
-    }
-
-    if (
-      !ComputeProbabilityMap(
-        this.options.eval,
-        (x) => x,
-        object.id && object.id.name
-      )
-    ) {
-      return;
-    }
-
-    object.$eval = (o, p) => {
-      var name;
-      var requiresMove = false;
-      if (object.type == "FunctionDeclaration") {
-        name = object.id.name;
-        object.type = "FunctionExpression";
-        object.id = null;
-        requiresMove = Array.isArray(p[0]) && isBlock(p[1]);
-      }
-
-      var code = compileJsSync(object, this.options);
-      if (object.type == "FunctionExpression") {
-        code = "(" + code + ")";
-      }
-
-      var literal = Literal(code);
-
-      var expr: Node = CallExpression(Identifier("eval"), [literal]);
-      if (name) {
-        expr = VariableDeclaration(VariableDeclarator(name, expr));
-      }
-
-      if (requiresMove) {
-        prepend(p[1], expr);
-        p[0].splice(p[0].indexOf(object), 1);
-      } else {
-        this.replace(object, expr);
-      }
-    };
-  }
-}

package/src/transforms/identifier/nameRecycling.ts

@@ -1,280 +0,0 @@
-import { ok } from "assert";
-import { ObfuscateOrder } from "../../order";
-import { ComputeProbabilityMap } from "../../probability";
-import { getBlock, isBlock, walk } from "../../traverse";
-import {
-  AssignmentExpression,
-  ExpressionStatement,
-  Identifier,
-  Location,
-  VariableDeclarator,
-} from "../../util/gen";
-import {
-  containsLexicallyBoundVariables,
-  getFunctionParameters,
-  getIdentifierInfo,
-} from "../../util/identifiers";
-import {
-  getDefiningContext,
-  getReferencingContexts,
-  getVarContext,
-  isForInitialize,
-  isFunction,
-  isVarContext,
-} from "../../util/insert";
-import Transform from "../transform";
-
-/**
- * Statement-based variable recycling.
- *
- * ```js
- * // Input
- * function percentage(decimal) {
- *   var multiplied = x * 100;
- *   var floored = Math.floor(multiplied);
- *   var output = floored + "%"
- *   return output;
- * }
- *
- * // Output
- * function percentage(decimal) {
- *   var multiplied = x * 100;
- *   var floored = Math.floor(multiplied);
- *   multiplied = floored + "%";
- *   return multiplied;
- * }
- * ```
- */
-export default class NameRecycling extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.NameRecycling);
-  }
-
-  match(object, parents) {
-    return isBlock(object);
-  }
-
-  transform(object, parents) {
-    return () => {
-      if (containsLexicallyBoundVariables(object, parents)) {
-        return;
-      }
-
-      var context = getVarContext(object, parents);
-
-      var stmts = [...object.body];
-      ok(Array.isArray(stmts));
-
-      var definedMap = new Map<number, Set<string>>();
-      var referencedMap = new Map<number, Set<string>>();
-      var nodeMap = new Map<number, Map<string, Location[]>>();
-
-      var lastReferenceMap = new Map<string, number>();
-
-      var defined = new Set<string>();
-      var illegal = new Set<string>();
-
-      var fn = isFunction(parents[0]) ? parents[0] : null;
-      if (fn) {
-        definedMap.set(
-          -1,
-          new Set(
-            getFunctionParameters(fn, parents.slice(1)).map((x) => x[0].name)
-          )
-        );
-      }
-
-      stmts.forEach((stmt, i) => {
-        var definedHere = new Set<string>();
-        var referencedHere = new Set<string>();
-        var nodesHere = new Map<string, Location[]>();
-
-        walk(stmt, [object.body, object, ...parents], (o, p) => {
-          if (o.type == "Identifier") {
-            return () => {
-              var info = getIdentifierInfo(o, p);
-              if (!info.spec.isReferenced) {
-                return;
-              }
-
-              var comparingContext = info.spec.isDefined
-                ? getDefiningContext(o, p)
-                : getReferencingContexts(o, p).find((x) => isVarContext(x));
-
-              if (comparingContext !== context) {
-                illegal.add(o.name);
-                this.log(o.name, "is different context");
-              } else {
-                if (!nodesHere.has(o.name)) {
-                  nodesHere.set(o.name, [[o, p]]);
-                } else {
-                  nodesHere.get(o.name).push([o, p]);
-                }
-
-                if (info.spec.isDefined) {
-                  // Function Declarations can be used before they're defined, if so, don't change this
-                  if (
-                    info.isFunctionDeclaration &&
-                    lastReferenceMap.has(o.name)
-                  ) {
-                    illegal.add(o.name);
-                  }
-                  if (
-                    defined.has(o.name) ||
-                    getBlock(o, p) !== object ||
-                    info.isImportSpecifier
-                  ) {
-                    illegal.add(o.name);
-                  }
-                  defined.add(o.name);
-                  definedHere.add(o.name);
-                } else {
-                  referencedHere.add(o.name);
-                }
-              }
-
-              lastReferenceMap.set(o.name, i);
-            };
-          }
-        });
-
-        // console.log(i, definedHere);
-
-        definedMap.set(i, definedHere);
-        referencedMap.set(i, referencedHere);
-        nodeMap.set(i, nodesHere);
-      });
-
-      this.log(illegal);
-
-      illegal.forEach((name) => {
-        nodeMap.forEach((value) => {
-          value.delete(name);
-        });
-      });
-
-      var available = new Set<string>();
-      var newNames = Object.create(null);
-
-      stmts.forEach((stmt, i) => {
-        var nodes = nodeMap.get(i);
-
-        nodes.forEach((locations, name) => {
-          var newName = newNames[name];
-
-          if (!newName) {
-            var canChange = false;
-
-            if (
-              object.type == "Program" &&
-              !ComputeProbabilityMap(this.options.renameGlobals, (x) => x, name)
-            ) {
-              return;
-            }
-
-            if (defined.has(name) && definedMap.get(i).has(name)) {
-              canChange = true;
-            }
-
-            if (!canChange) {
-              return;
-            }
-
-            if (available.size) {
-              newName = available.keys().next().value;
-              available.delete(newName);
-
-              ok(name !== newName);
-              newNames[name] = newName;
-
-              defined.delete(name);
-
-              this.log(name, "->", newName);
-            }
-          }
-        });
-
-        nodes.forEach((locations, name) => {
-          var newName = newNames[name];
-
-          if (newName) {
-            locations.forEach(([object, parents]) => {
-              object.name = newName;
-
-              var declaratorIndex = parents.findIndex(
-                (p) => p.type == "VariableDeclarator"
-              );
-              if (
-                declaratorIndex !== -1 &&
-                parents[declaratorIndex].id ===
-                  (parents[declaratorIndex - 1] || object)
-              ) {
-                var value =
-                  parents[declaratorIndex].init || Identifier("undefined");
-
-                var expr = AssignmentExpression(
-                  "=",
-                  parents[declaratorIndex].id,
-                  value
-                );
-
-                if (parents[declaratorIndex + 1].length === 1) {
-                  if (
-                    isForInitialize(
-                      parents[declaratorIndex + 2],
-                      parents.slice(3)
-                    )
-                  ) {
-                    this.replace(parents[declaratorIndex + 2], expr);
-                  } else {
-                    this.replace(
-                      parents[declaratorIndex + 2],
-                      ExpressionStatement(expr)
-                    );
-                  }
-                } else {
-                  this.replace(
-                    parents[declaratorIndex],
-                    VariableDeclarator(this.getPlaceholder(), expr)
-                  );
-                }
-              } else {
-                if (parents[0].type == "FunctionDeclaration") {
-                  this.replace(
-                    parents[0],
-                    ExpressionStatement(
-                      AssignmentExpression("=", Identifier(newName), {
-                        ...parents[0],
-                        type: "FunctionExpression",
-                        id: null,
-                      })
-                    )
-                  );
-                } else if (parents[0].type == "ClassDeclaration") {
-                  this.replace(
-                    parents[0],
-                    ExpressionStatement(
-                      AssignmentExpression("=", Identifier(newName), {
-                        ...parents[0],
-                        type: "ClassExpression",
-                      })
-                    )
-                  );
-                }
-              }
-            });
-          }
-
-          if (defined.has(name)) {
-            var lastRef = lastReferenceMap.get(name);
-            var isDecommissioned = lastRef === i;
-
-            if (isDecommissioned) {
-              available.add(name);
-            }
-          }
-        });
-      });
-    };
-  }
-}