Merge pull request #83 from MichaelXF/dev

1.5.9

Author: MichaelXF

CHANGELOG.md

@@ -1,3 +1,40 @@
+# `1.5.9`
+Big update
+
+This updates comes with many bug fixes:
+
+- Fixed [#72](https://github.com/MichaelXF/js-confuser/issues/72)
+- - ES5 to handle Class Fields
+
+Note: The `ES5` option is not meant to replace Babel. It is only intended to undo ES6 features the obfuscator may have added to your code.
+
+- Fixed [#74](https://github.com/MichaelXF/js-confuser/issues/74)
+- - Anti Tooling to not break Symbols
+
+- Fixed [#75](https://github.com/MichaelXF/js-confuser/issues/75)
+- - Minify to properly handle Object constructors
+
+- Fixed [#76](https://github.com/MichaelXF/js-confuser/issues/76)
+- - Minify to not cause syntax errors when objects used `^`, `` ` ``, `[`, `]` as property keys
+
+- Fixed [#77](https://github.com/MichaelXF/js-confuser/issues/77)
+- - Dispatcher to not break code that uses generic names like `toString` and `hasOwnProperty`
+
+- Fixed [#78](https://github.com/MichaelXF/js-confuser/issues/78)
+- - Object Extraction to not error on objects with spread elements
+
+- Fixed [#79](https://github.com/MichaelXF/js-confuser/issues/79)
+- - JsConfuser now supports `BigInt` literals
+
+- Fixed [#80](https://github.com/MichaelXF/js-confuser/issues/80)
+- - Rename Variables to not break code that had `var` and `let` variables in the same scope
+
+- Fixed [#81](https://github.com/MichaelXF/js-confuser/issues/81)
+- - Control Flow Flattening to not break `typeof` expressions
+
+- Fixed [#82](https://github.com/MichaelXF/js-confuser/issues/82)
+- - String Concealing to not break class constructors
+
 # `1.5.8`
 Several fixes
 

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",

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;

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 &&

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));
   }
 

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,
 

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)
               )
             )

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 },

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;
             }
 

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"
         ) {

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 {

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,

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);