js-confuser 1.5.8 → 1.5.9

package/dist/transforms/minify.js

@@ -21,6 +21,8 @@ var _assert = require("assert");
 
 var _scope = require("../util/scope");
 
+var _template = _interopRequireDefault(require("../templates/template"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
@@ -34,12 +36,13 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * - `x['y']` **->** `x.y`
  */
 class Minify extends _transform.default {
+  /**
+   * A helper function that is introduced preserve function semantics
+   */
   constructor(o) {
     super(o, _order.ObfuscateOrder.Minify);
 
-    _defineProperty(this, "variables", void 0);
-
-    this.variables = new Map();
+    _defineProperty(this, "arrowFunctionName", void 0);
   }
 
   match(object, parents) {
@@ -212,15 +215,28 @@ class Minify extends _transform.default {
         });
 
         if (canTransform) {
+          if (!this.arrowFunctionName) {
+            this.arrowFunctionName = this.getPlaceholder();
+            (0, _insert.append)(parents[parents.length - 1] || object, (0, _template.default)("\n            function ".concat(this.arrowFunctionName, "(arrowFn){\n              return function(){ return arrowFn(...arguments) }\n            }\n            ")).single());
+          }
+
+          const wrap = object => {
+            return (0, _gen.CallExpression)((0, _gen.Identifier)(this.arrowFunctionName), [(0, _insert.clone)(object)]);
+          };
+
           if (object.type == "FunctionExpression") {
             object.type = "ArrowFunctionExpression";
+            this.replace(object, wrap((0, _insert.clone)(object)));
           } else {
             var arrow = { ...(0, _insert.clone)(object),
               type: "ArrowFunctionExpression"
             };
-            this.replace(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(object.id.name, arrow)));
+            this.replace(object, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(object.id.name, wrap(arrow))));
             var x = this.transform(arrow, []);
-            x();
+
+            if (typeof x === "function") {
+              x();
+            }
           }
         }
       };
@@ -372,7 +388,7 @@ class Minify extends _transform.default {
           object.alternate = null;
         }
 
-        if (object.consequent.body.length == 1 && object.alternate && object.alternate.body.length == 1) {
+        if (object.consequent && object.consequent.body && object.consequent.body.length == 1 && object.alternate && object.alternate.body.length == 1) {
           var stmt1 = (0, _insert.clone)(object.consequent.body[0]);
           var stmt2 = (0, _insert.clone)(object.alternate.body[0]); // if (a) {return b;} else {return c;} -> return a ? b : c;
 

package/dist/transforms/rgf.js

@@ -241,7 +241,8 @@ class RGF extends _transform.default {
                     // fn
                     // In most cases the identifier is being used like this (call expression, or referenced to be called later)
                     // Replace it with a simple wrapper function that will pass on the reference array
-                    var conditionalExpression = (0, _gen.ConditionalExpression)((0, _template.default)("typeof ".concat(referenceArray, "[").concat(index, "] === \"function\" && ").concat(referenceArray, "[").concat(index, "][\"").concat(referenceSignatures[index] || "_", "\"]")).single().expression, (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)((0, _gen.CallExpression)(memberExpression, [(0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]), memberExpression);
+                    var conditionalExpression = (0, _gen.ConditionalExpression)((0, _template.default)("typeof ".concat(referenceArray, "[").concat(index, "] === \"function\" && ").concat(referenceArray, "[").concat(index, "][\"").concat(referenceSignatures[index] || "_", "\"]")).single().expression, (0, _gen.FunctionExpression)([], [(0, _gen.ReturnStatement)( // clone() is required!
+                    (0, _gen.CallExpression)((0, _insert.clone)(memberExpression), [(0, _gen.Identifier)(referenceArray), (0, _gen.SpreadElement)((0, _gen.Identifier)("arguments"))]))]), memberExpression);
                     this.replace(o, conditionalExpression);
                   }
                 }
@@ -258,8 +259,6 @@ class RGF extends _transform.default {
 
         let [object, parents] = _ref2;
         var name = object === null || object === void 0 ? void 0 : (_object$id2 = object.id) === null || _object$id2 === void 0 ? void 0 : _object$id2.name;
-        var hasName = !!name;
-        var params = object.params.map(x => x.name) || [];
         var signature = referenceSignatures[names.get(name)];
         var embeddedName = name || this.getPlaceholder(); // Since `new Function` is completely isolated, create an entire new obfuscator and run remaining transformations.
         // RGF runs early and needs completed code before converting to a string.
@@ -272,7 +271,8 @@ class RGF extends _transform.default {
             integrity: false
           },
           eval: false,
-          hideInitializingCode: false
+          hideInitializingCode: false,
+          stringEncoding: false
         });
         var transforms = Object.values(obfuscator.transforms).filter(x => x.priority > this.priority);
         var embeddedFunction = { ...object,

package/dist/transforms/stack.js

@@ -44,7 +44,7 @@ class Stack extends _transform.default {
     return () => {
       // Uncaught SyntaxError: Getter must not have any formal parameters.
       // Uncaught SyntaxError: Setter must have exactly one formal parameter
-      var propIndex = parents.findIndex(x => x.type == "Property");
+      var propIndex = parents.findIndex(x => x.type === "Property" || x.type === "MethodDefinition");
 
       if (propIndex !== -1) {
         if (parents[propIndex].value === (parents[propIndex - 1] || object)) {

package/dist/transforms/string/stringConcealing.js

@@ -166,10 +166,10 @@ class StringConcealing extends _transform.default {
       var callExpr = (0, _gen.CallExpression)((0, _gen.Identifier)(fnName), [(0, _gen.Literal)(index)]); // use `.apply` to fool automated de-obfuscators
 
       if (Math.random() > 0.5) {
-        callExpr = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Identifier)("apply"), false), [(0, _gen.ThisExpression)(), (0, _gen.ArrayExpression)([(0, _gen.Literal)(index)])]);
+        callExpr = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Identifier)("apply"), false), [(0, _gen.Identifier)("undefined"), (0, _gen.ArrayExpression)([(0, _gen.Literal)(index)])]);
       } // use `.call`
       else if (Math.random() > 0.5) {
-        callExpr = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Identifier)("call"), false), [(0, _gen.ThisExpression)(), (0, _gen.Literal)(index)]);
+        callExpr = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Identifier)("call"), false), [(0, _gen.Identifier)("undefined"), (0, _gen.Literal)(index)]);
       }
 
       var referenceType = "call";

package/dist/traverse.js

@@ -40,15 +40,7 @@ function isBlock(object) {
 }
 
 function walk(object, parents, onEnter) {
-  let seen = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Set();
-
   if (typeof object === "object" && object) {
-    if (seen.has(object)) {
-      console.log(object);
-      throw new Error("Already seen: " + object.type);
-    }
-
-    seen.add(object);
     var newParents = [object, ...parents];
 
     if (!Array.isArray(object)) {

package/dist/util/compare.js

@@ -59,8 +59,8 @@ function isValidIdentifier(name) {
     return false;
   }
 
-  var x = name.match(/^[A-z$_][A-z0-9$_]*/);
-  return x && x[0] == name;
+  var x = name.match(/^[A-Za-z$_][A-Za-z0-9$_]*/);
+  return !!(x && x[0] == name);
 }
 
 function isInsideType(type, object, parents) {

package/dist/util/insert.js

@@ -139,8 +139,12 @@ function getDefiningContext(o, p) {
     var variableDeclaration = p.find(x => x.type == "VariableDeclaration");
     (0, _assert.ok)(variableDeclaration);
 
-    if (variableDeclaration.kind === "let") {
-      return getLexContext(o, p);
+    if (variableDeclaration.kind === "let" || variableDeclaration.kind === "const") {
+      var context = getVarContext(o, p);
+
+      if (context && context.type === "Program") {
+        return getLexContext(o, p);
+      }
     }
   }
 
@@ -287,15 +291,21 @@ function prepend(block) {
   }
 
   if (block.type == "Program") {
-    var decs = 0;
+    var moveBy = 0;
     block.body.forEach((stmt, i) => {
       if (stmt.type == "ImportDeclaration") {
-        if (decs == i) {
-          decs++;
+        if (moveBy == i) {
+          moveBy++;
+        }
+      }
+
+      if (stmt.type === "ExpressionStatement" && typeof stmt.directive === "string") {
+        if (moveBy == i) {
+          moveBy++;
         }
       }
     });
-    block.body.splice(decs, 0, ...nodes);
+    block.body.splice(moveBy, 0, ...nodes);
   } else {
     getBlockBody(block).unshift(...nodes);
   }
@@ -351,6 +361,10 @@ function isForInitialize(o, p) {
   (0, _identifiers.validateChain)(o, p);
   var forIndex = p.findIndex(x => x.type == "ForStatement" || x.type == "ForInStatement" || x.type == "ForOfStatement");
 
+  if (p.slice(0, forIndex).find(x => ["ArrowFunctionExpression", "BlockStatement"].includes(x.type))) {
+    return false;
+  }
+
   if (forIndex !== -1) {
     if (p[forIndex].type == "ForStatement") {
       if (p[forIndex].init == (p[forIndex - 1] || o)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/index.ts

@@ -4,6 +4,7 @@ import Obfuscator from "./obfuscator";
 import Transform from "./transforms/transform";
 import { remove$Properties } from "./util/object";
 import presets from "./presets";
+import { performance } from "perf_hooks";
 
 import * as assert from "assert";
 import { correctOptions, ObfuscateOptions, validateOptions } from "./options";
@@ -85,8 +86,8 @@ var JsConfuser: IJsConfuser = async function (
   return result;
 } as any;
 
-export var debugTransformations: IJsConfuserDebugTransformations =
-  async function debugTransformations(
+export const debugTransformations: IJsConfuserDebugTransformations =
+  async function (
     code: string,
     options: ObfuscateOptions
   ): Promise<{ name: string; code: string; ms: number }[]> {
@@ -115,28 +116,65 @@ export var debugTransformations: IJsConfuserDebugTransformations =
     return frames;
   };
 
-export var debugObfuscation: IJsConfuserDebugObfuscation =
-  async function debugTransformations(
-    code: string,
-    options: ObfuscateOptions,
-    callback: (name: string, complete: number, totalTransforms: number) => void
-  ): Promise<string> {
-    validateOptions(options);
-    options = await correctOptions(options);
+/**
+ * This method is used by the obfuscator website to display a progress bar and additional information
+ * about the obfuscation.
+ *
+ * @param code - Source code to obfuscate
+ * @param options - Options
+ * @param callback - Progress callback, called after each transformation
+ * @returns
+ */
+export const debugObfuscation: IJsConfuserDebugObfuscation = async function (
+  code: string,
+  options: ObfuscateOptions,
+  callback: (name: string, complete: number, totalTransforms: number) => void
+) {
+  const startTime = performance.now();
 
-    var tree = parseSync(code);
-    var obfuscator = new Obfuscator(options);
-    var totalTransforms = obfuscator.array.length;
+  validateOptions(options);
+  options = await correctOptions(options);
 
-    obfuscator.on("debug", (name: string, tree: Node, i: number) => {
-      callback(name, i, totalTransforms);
-    });
+  const beforeParseTime = performance.now();
 
-    await obfuscator.apply(tree, true);
+  var tree = parseSync(code);
+
+  const parseTime = performance.now() - beforeParseTime;
+
+  var obfuscator = new Obfuscator(options);
+  var totalTransforms = obfuscator.array.length;
+
+  var transformationTimes = Object.create(null);
+  var currentTransformTime = performance.now();
+
+  obfuscator.on("debug", (name: string, tree: Node, i: number) => {
+    var nowTime = performance.now();
+    transformationTimes[name] = nowTime - currentTransformTime;
+    currentTransformTime = nowTime;
+
+    callback(name, i, totalTransforms);
+  });
+
+  await obfuscator.apply(tree, true);
+
+  const beforeCompileTime = performance.now();
+
+  var output = await compileJs(tree, options);
+
+  const compileTime = performance.now() - beforeCompileTime;
+
+  const endTime = performance.now();
 
-    var output = compileJs(tree, options);
-    return output;
+  return {
+    obfuscated: output,
+    transformationTimes: transformationTimes,
+    obfuscationTime: endTime - startTime,
+    parseTime: parseTime,
+    compileTime: compileTime,
+    totalTransforms: totalTransforms,
+    totalPossibleTransforms: obfuscator.totalPossibleTransforms,
   };
+};
 
 JsConfuser.obfuscate = obfuscate;
 JsConfuser.obfuscateAST = obfuscateAST;

package/src/obfuscator.ts

@@ -47,17 +47,22 @@ export default class Obfuscator extends EventEmitter {
   state: "transform" | "eval" = "transform";
   generated: Set<string>;
 
+  totalPossibleTransforms: number;
+
   constructor(public options: ObfuscateOptions) {
     super();
 
     this.varCount = 0;
     this.transforms = Object.create(null);
     this.generated = new Set();
+    this.totalPossibleTransforms = 0;
 
     this.push(new Preparation(this));
     this.push(new RenameLabels(this));
 
     const test = <T>(map: ProbabilityMap<T>, ...transformers: any[]) => {
+      this.totalPossibleTransforms += transformers.length;
+
       if (isProbabilityMapProbable(map)) {
         // options.verbose && console.log("+ Added " + transformer.name);
 
@@ -97,7 +102,7 @@ export default class Obfuscator extends EventEmitter {
     test(options.stack, Stack);
     test(true, AntiTooling);
     test(options.hideInitializingCode, HideInitializingCode);
-    test(options.hexadecimalNumbers, HexadecimalNumbers);
+    test(true, HexadecimalNumbers); // BigInt support is included
 
     if (
       options.lock &&

package/src/options.ts

@@ -867,8 +867,7 @@ export async function correctOptions(
     options.compact = true; // self defending forcibly enables this
   }
 
-  // options.globalVariables was never used.
-  // GlobalConcealing implicitly determines a global to be a variable referenced but never defined or modified.
+  // options.globalVariables outlines generic globals that should be present in the execution context
   if (!options.hasOwnProperty("globalVariables")) {
     options.globalVariables = new Set([]);
 
@@ -908,6 +907,10 @@ export async function correctOptions(
       "Array",
       "Proxy",
       "Error",
+      "TypeError",
+      "ReferenceError",
+      "RangeError",
+      "EvalError",
       "setTimeout",
       "clearTimeout",
       "setInterval",
@@ -919,6 +922,11 @@ export async function correctOptions(
       "module",
       "isNaN",
       "isFinite",
+      "Set",
+      "Map",
+      "WeakSet",
+      "WeakMap",
+      "Symbol",
     ].forEach((x) => options.globalVariables.add(x));
   }
 

package/src/order.ts

@@ -44,11 +44,11 @@ export enum ObfuscateOrder {
 
   MovedDeclarations = 26,
 
-  RenameVariables = 27,
+  RenameLabels = 27,
 
-  RenameLabels = 28,
+  Minify = 28,
 
-  Minify = 30,
+  RenameVariables = 30,
 
   ES5 = 31,
 

package/src/transforms/antiTooling.ts

@@ -45,7 +45,7 @@ export default class AntiTooling extends Transform {
             exprs[0],
             ExpressionStatement(
               UnaryExpression(
-                choice(["typeof", "void", "~", "!", "+"]),
+                choice(["typeof", "void", "!"]),
                 SequenceExpression(flattened)
               )
             )

package/src/transforms/controlFlowFlattening/expressionObfuscation.ts

@@ -20,7 +20,13 @@ export default class ExpressionObfuscation extends Transform {
         if (stmt.type == "ExpressionStatement") {
           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 +44,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/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
@@ -469,7 +470,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

@@ -266,7 +266,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 {

package/src/transforms/eval.ts

@@ -28,6 +28,24 @@ export default class Eval extends Transform {
   }
 
   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,

package/src/transforms/extraction/duplicateLiteralsRemoval.ts

@@ -159,7 +159,7 @@ export default class DuplicateLiteralsRemoval extends Transform {
       var body = [];
       var thisShift = getRandomInteger(-250, 250);
       // the name of the getter
-      getterName = this.getPlaceholder();
+      getterName = this.getPlaceholder() + "_dLR_" + this.fnGetters.size;
 
       if (basedOn) {
         var shift = this.fnShifts.get(basedOn);
@@ -268,20 +268,20 @@ export default class DuplicateLiteralsRemoval extends Transform {
           this.arrayExpression = ArrayExpression([]);
         }
 
-        var first = this.first.get(value);
-        if (first) {
+        var firstLocation = this.first.get(value);
+        if (firstLocation) {
           this.first.set(value, null);
           var index = this.map.size;
 
           ok(!this.map.has(value));
           this.map.set(value, index);
 
-          this.toCaller(first[0], first[1], index);
-
           var pushing = clone(object);
           this.arrayExpression.elements.push(pushing);
 
           ok(this.arrayExpression.elements[index] === pushing);
+
+          this.toCaller(firstLocation[0], firstLocation[1], index);
         }
 
         var index = this.map.get(value);

package/src/transforms/extraction/objectExtraction.ts

@@ -100,11 +100,18 @@ export default class ObjectExtraction extends Transform {
               );
 
               if (nonInitOrComputed) {
-                this.log(
-                  name +
-                    " has non-init/computed property: " +
-                    nonInitOrComputed.key.name || nonInitOrComputed.key.value
-                );
+                if (nonInitOrComputed.key) {
+                  this.log(
+                    name +
+                      " has non-init/computed property: " +
+                      nonInitOrComputed.key.name || nonInitOrComputed.key.value
+                  );
+                } else {
+                  this.log(
+                    name + " has spread-element or other type of property"
+                  );
+                }
+
                 illegal.add(name);
                 return;
               } else {