js-confuser 1.2.1 → 1.4.1

package/dist/util/identifiers.js

@@ -4,8 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.validateChain = validateChain;
-exports.isWithinClass = isWithinClass;
-exports.isWithin = isWithin;
 exports.getIdentifierInfo = getIdentifierInfo;
 exports.getDefiningIdentifier = getDefiningIdentifier;
 exports.isFunctionParameter = isFunctionParameter;
@@ -44,14 +42,6 @@ function validateChain(object, parents) {
     }
   }
 }
-
-function isWithinClass(object, parents) {
-  return isWithin(object, parents, "ClassDeclaration") || isWithin(object, parents, "ClassExpression");
-}
-
-function isWithin(object, parents, type) {
-  return [object, ...parents].some(x => x.type == type);
-}
 /**
  * Returns detailed information about the given Identifier node.
  * @param object
@@ -99,10 +89,11 @@ function getIdentifierInfo(object, parents) {
   var isImportSpecifier = (parent.type == "ImportDefaultSpecifier" || parent.type == "ImportSpecifier") && parent.local == object;
   var isFunctionCall = parent.callee == object; // NewExpression and CallExpression
 
-  var isAssignmentLeft = parent.type == "AssignmentExpression" && parent.left == object;
-  var isAssignmentValue = parent.type == "AssignmentExpression" && parent.right == object;
+  var assignmentIndex = parents.findIndex(p => p.type === "AssignmentExpression");
+  var isAssignmentLeft = assignmentIndex !== -1 && parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object);
+  var isAssignmentValue = assignmentIndex !== -1 && parents[assignmentIndex].right === (parents[assignmentIndex - 1] || object);
   var isUpdateExpression = parent.type == "UpdateExpression";
-  var isClassDeclaration = parent.type == "ClassDeclaration" && parent.id == object;
+  var isClassDeclaration = (parent.type == "ClassDeclaration" || parent.type == "ClassExpression") && parent.id == object;
   var isMethodDefinition = parent.type == "MethodDefinition" && parent.key == object && !parent.computed;
   var isMetaProperty = parent.type == "MetaProperty";
   var isLabel = parent.type == "LabeledStatement" && parent.label == object; // Fix 1: Labels are properly identified
@@ -300,7 +291,7 @@ function getDefiningIdentifier(object, parents) {
   }
 }
 
-function isFunctionParameter(o, p) {
+function isFunctionParameter(o, p, c) {
   (0, _assert.ok)(o);
   (0, _assert.ok)(p);
   validateChain(o, p);
@@ -315,7 +306,7 @@ function isFunctionParameter(o, p) {
     return false;
   }
 
-  var c = (0, _insert.getVarContext)(o, p);
+  c = c || (0, _insert.getVarContext)(o, p);
 
   if (c === object) {
     var pIndex = p.indexOf(object.params);
@@ -327,8 +318,7 @@ function isFunctionParameter(o, p) {
     var param = p[pIndex - 1] || o;
     var paramIndex = object.params.indexOf(param);
     (0, _assert.ok)(paramIndex !== -1);
-    var sliced = p.slice(p.indexOf(paramIndex));
-    (0, _assert.ok)(!sliced.includes(o));
+    var sliced = p.slice(0, pIndex);
     var isReferenced = true;
     var i = 0;
 
@@ -342,7 +332,7 @@ function isFunctionParameter(o, p) {
           break;
         }
 
-        if (node.type == "ObjectPattern" && node.key === down) {
+        if (node.type == "Property" && node.key === down && sliced[i + 2] && sliced[i + 2].type == "ObjectPattern") {
           isReferenced = false;
           break;
         }
@@ -365,7 +355,7 @@ function getFunctionParameters(object, parents) {
   var locations = [];
   (0, _traverse.walk)(object.params, [object, ...parents], (o, p) => {
     if (o.type == "Identifier") {
-      if (isFunctionParameter(o, p)) {
+      if (isFunctionParameter(o, p, object)) {
         locations.push([o, p]);
       }
     }

package/dist/util/insert.js

@@ -21,7 +21,6 @@ exports.prepend = prepend;
 exports.append = append;
 exports.clone = clone;
 exports.isForInitialize = isForInitialize;
-exports.isInBranch = isInBranch;
 
 var _assert = require("assert");
 
@@ -151,27 +150,15 @@ function getDefiningContext(o, p) {
   return getVarContext(o, p);
 }
 
-function getReferencingContexts(o, p) {
+function getReferencingContexts(o, p, info) {
   (0, _identifiers.validateChain)(o, p);
   (0, _assert.ok)(o.type == "Identifier");
-  var info = (0, _identifiers.getIdentifierInfo)(o, p);
-  (0, _assert.ok)(info.spec.isReferenced);
-  var assignmentPatternIndex = p.findIndex(x => x.type == "AssignmentPattern");
-
-  if (assignmentPatternIndex != -1) {
-    if (p[assignmentPatternIndex].right == (p[assignmentPatternIndex - 1] || o)) {
-      var sliced = p.slice(assignmentPatternIndex);
-      var fnIndex = sliced.findIndex(x => isFunction(x));
-      var associatedFn = sliced[fnIndex];
 
-      if (fnIndex !== -1 && sliced[fnIndex].params == (sliced[fnIndex - 1] || o)) {
-        if (associatedFn == getVarContext(o, p)) {
-          return isLexContext(associatedFn.body) ? [associatedFn, associatedFn.body] : [associatedFn];
-        }
-      }
-    }
+  if (!info) {
+    info = (0, _identifiers.getIdentifierInfo)(o, p);
   }
 
+  (0, _assert.ok)(info.spec.isReferenced);
   return [getVarContext(o, p), getLexContext(o, p)];
 }
 
@@ -328,36 +315,15 @@ function isForInitialize(o, p) {
 
   if (forIndex !== -1) {
     if (p[forIndex].type == "ForStatement") {
-      if (p[forIndex].init == p[forIndex - 1] || o) {
+      if (p[forIndex].init == (p[forIndex - 1] || o)) {
         return "initializer";
       }
     } else {
-      if (p[forIndex].left == p[forIndex - 1] || o) {
+      if (p[forIndex].left == (p[forIndex - 1] || o)) {
         return "left-hand";
       }
     }
   }
 
   return false;
-}
-
-function isInBranch(object, parents, context) {
-  (0, _assert.ok)(object);
-  (0, _assert.ok)(parents);
-  (0, _assert.ok)(context);
-  (0, _assert.ok)(parents.includes(context));
-  var definingContext = parents[0].type == "FunctionDeclaration" && parents[0].id == object ? getVarContext(parents[0], parents.slice(1)) : getVarContext(object, parents);
-  var contextIndex = parents.findIndex(x => x === context);
-  var slicedParents = parents.slice(0, contextIndex);
-  (0, _assert.ok)(!slicedParents.includes(object), "slicedParents includes object");
-  var slicedTypes = new Set(slicedParents.map(x => x.type));
-  var isBranch = definingContext !== context;
-
-  if (!isBranch) {
-    if (["IfStatement", "ForStatement", "ForInStatement", "ForOfStatement", "WhileStatement", "DoWhileStatement", "SwitchStatement", "ConditionalExpression", "LogicalExpression", "TryStatement", "ChainExpression", "BinaryExpression", "FunctionExpression", "FunctionDeclaration", "ArrowFunctionExpression", "ClassExpression", "ClassDeclaration"].find(x => slicedTypes.has(x))) {
-      isBranch = true;
-    }
-  }
-
-  return isBranch;
 }

package/dist/util/scope.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isLexicalScope = isLexicalScope;
+exports.getLexicalScope = getLexicalScope;
+
+var _traverse = require("../traverse");
+
+function isLexicalScope(object) {
+  return (0, _traverse.isBlock)(object) || object.type == "SwitchCase";
+}
+
+function getLexicalScope(object, parents) {
+  return [object, ...parents].find(node => isLexicalScope(node));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.2.1",
+  "version": "1.4.1",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -22,7 +22,7 @@
   "author": "MichaelXF",
   "license": "MIT",
   "dependencies": {
-    "acorn": "^8.4.0",
+    "acorn": "^8.5.0",
     "escodegen": "^2.0.0"
   },
   "devDependencies": {

package/src/options.ts

@@ -224,7 +224,7 @@ export interface ObfuscateOptions {
   /**
    * ### `stringConcealing`
    *
-   * [String Concealing](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-concealing) involves encoding strings to conceal plain-text values. (`true/false`)
+   * [String Concealing](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-concealing) involves encoding strings to conceal plain-text values. (`true/false/0-1`)
    *
    * `"console"` -> `decrypt('<~@rH7+Dert~>')`
    *
@@ -237,7 +237,7 @@ export interface ObfuscateOptions {
   /**
    * ### `stringEncoding`
    *
-   * [String Encoding](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-encoding) transforms a string into an encoded representation. (`true/false`)
+   * [String Encoding](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-encoding) transforms a string into an encoded representation. (`true/false/0-1`)
    *
    * `"console"` -> `'\x63\x6f\x6e\x73\x6f\x6c\x65'`
    *
@@ -252,7 +252,7 @@ export interface ObfuscateOptions {
   /**
    * ### `stringSplitting`
    *
-   * [String Splitting](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-splitting) splits your strings into multiple expressions. (`true/false`)
+   * [String Splitting](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-splitting) splits your strings into multiple expressions. (`true/false/0-1`)
    *
    * `"console"` -> `String.fromCharCode(99) + 'ons' + 'ole'`
    *
@@ -447,6 +447,17 @@ export interface ObfuscateOptions {
   calculator?: ProbabilityMap<boolean>;
 
   lock?: {
+    /**
+     * ### `lock.selfDefending`
+     *
+     * Prevents the use of code beautifiers or formatters against your code.
+     *
+     * [Identical to Obfuscator.io's Self Defending](https://github.com/javascript-obfuscator/javascript-obfuscator#selfdefending)
+     *
+     * [See all settings here](https://github.com/MichaelXF/js-confuser/blob/master/README.md#options)
+     */
+    selfDefending?: boolean;
+
     /**
      * ### `lock.antiDebug`
      *
@@ -692,6 +703,7 @@ const validProperties = new Set([
   "shuffle",
   "stack",
   "verbose",
+  "globalVariables",
   "debugComments",
 ]);
 
@@ -837,6 +849,10 @@ export async function correctOptions(
     options.globalVariables = new Set(Object.keys(options.globalVariables));
   }
 
+  if (options.lock && options.lock.selfDefending) {
+    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.
   if (!options.hasOwnProperty("globalVariables")) {

package/src/parser.ts

@@ -18,8 +18,7 @@ export default async function parseJS(code: string): Promise<{
     var parsed = parseSync(code);
     return parsed as any;
   } catch (e) {
-    console.error(e);
-    throw new Error("Failed to parse code.");
+    throw e;
   }
 }
 

package/src/presets.ts

@@ -43,11 +43,11 @@ const highPreset: ObfuscateOptions = {
   renameVariables: true,
   renameGlobals: true,
   shuffle: { hash: 0.5, true: 0.5 },
+  stack: true,
   stringConcealing: true,
   stringCompression: true,
   stringEncoding: true,
   stringSplitting: 0.75,
-  stack: true,
 
   // Use at own risk
   eval: false,
@@ -68,7 +68,6 @@ const mediumPreset: ObfuscateOptions = {
   deadCode: 0.025,
   dispatcher: 0.75,
   duplicateLiteralsRemoval: 0.5,
-  flatten: true,
   globalConcealing: true,
   identifierGenerator: "randomized",
   minify: true,
@@ -78,6 +77,7 @@ const mediumPreset: ObfuscateOptions = {
   renameVariables: true,
   renameGlobals: true,
   shuffle: true,
+  stack: 0.5,
   stringConcealing: true,
   stringSplitting: 0.25,
 };

package/src/transforms/calculator.ts

@@ -34,104 +34,100 @@ export default class Calculator extends Transform {
     this.gen = this.getGenerator();
   }
 
+  apply(tree) {
+    super.apply(tree);
+
+    if (Object.keys(this.ops).length == 0) {
+      return;
+    }
+
+    var opArg = this.getPlaceholder();
+    var leftArg = this.getPlaceholder();
+    var rightArg = this.getPlaceholder();
+    var switchCases = [];
+
+    Object.keys(this.ops).forEach((operator) => {
+      var code = this.ops[operator];
+
+      var factory =
+        operator == "&&" || operator == "||"
+          ? LogicalExpression
+          : BinaryExpression;
+
+      var body = [
+        ReturnStatement(
+          factory(operator, Identifier(leftArg), Identifier(rightArg))
+        ),
+      ];
+
+      switchCases.push(SwitchCase(Literal(code), body));
+    });
+
+    var func = FunctionDeclaration(
+      this.calculatorFn,
+      [opArg, leftArg, rightArg].map((x) => Identifier(x)),
+      [SwitchStatement(Identifier(opArg), switchCases)]
+    );
+
+    prepend(tree, func);
+  }
+
   match(object: Node, parents: Node[]) {
-    return object.type == "Program" || object.type == "BinaryExpression";
+    return object.type == "BinaryExpression";
   }
 
   transform(object: Node, parents: Node[]) {
-    if (object.type == "Program") {
-      return () => {
-        var block = getBlock(object, parents);
-
-        if (Object.keys(this.ops).length == 0) {
-          return;
-        }
-
-        var opArg = this.getPlaceholder();
-        var leftArg = this.getPlaceholder();
-        var rightArg = this.getPlaceholder();
-        var switchCases = [];
-
-        Object.keys(this.ops).forEach((operator) => {
-          var code = this.ops[operator];
-
-          var factory =
-            operator == "&&" || operator == "||"
-              ? LogicalExpression
-              : BinaryExpression;
-
-          var body = [
-            ReturnStatement(
-              factory(operator, Identifier(leftArg), Identifier(rightArg))
-            ),
-          ];
-
-          switchCases.push(SwitchCase(Literal(code), body));
-        });
-
-        var func = FunctionDeclaration(
-          this.calculatorFn,
-          [opArg, leftArg, rightArg].map((x) => Identifier(x)),
-          [SwitchStatement(Identifier(opArg), switchCases)]
-        );
-
-        prepend(block, func);
-      };
+    var operator = object.operator;
+    var allowedOperators = new Set(["+", "-", "*", "/"]);
+    if (!allowedOperators.has(operator)) {
+      return;
     }
 
-    if (object.type == "BinaryExpression") {
-      var operator = object.operator;
-      if (!{ "+": 1, "-": 1, "*": 1, "/": 1 }[object.operator]) {
-        return;
-      }
+    var myPrecedence =
+      OPERATOR_PRECEDENCE[operator] +
+      Object.keys(OPERATOR_PRECEDENCE).indexOf(operator) / 100;
+    var precedences = parents.map(
+      (x) =>
+        x.type == "BinaryExpression" &&
+        OPERATOR_PRECEDENCE[x.operator] +
+          Object.keys(OPERATOR_PRECEDENCE).indexOf(x.operator) / 100
+    );
+
+    // corrupt AST
+    if (precedences.find((x) => x >= myPrecedence)) {
+      return;
+    }
+    if (
+      parents.find((x) => x.$dispatcherSkip || x.type == "BinaryExpression")
+    ) {
+      return;
+    }
 
-      var myPrecedence =
-        OPERATOR_PRECEDENCE[operator] +
-        Object.keys(OPERATOR_PRECEDENCE).indexOf(operator) / 100;
-      var maxParentPrecedence = parents
-        .map(
-          (x) =>
-            x.type == "BinaryExpression" &&
-            OPERATOR_PRECEDENCE[x.operator] +
-              Object.keys(OPERATOR_PRECEDENCE).indexOf(x.operator) / 100
-        )
-        .sort()
-        .pop();
-
-      // corrupt AST
-      if (maxParentPrecedence && maxParentPrecedence > myPrecedence) {
-        return;
+    return () => {
+      if (typeof this.ops[operator] !== "number") {
+        var newState;
+        do {
+          newState = getRandomInteger(
+            -1000,
+            1000 + Object.keys(this.ops).length * 5
+          );
+        } while (this.statesUsed.has(newState));
+
+        ok(!isNaN(newState));
+
+        this.statesUsed.add(newState);
+        this.ops[operator] = newState;
+        this.log(operator, `calc(${newState}, left, right)`);
       }
-      return () => {
-        if (parents.find((x) => x.$dispatcherSkip)) {
-          return;
-        }
-
-        if (typeof this.ops[operator] !== "number") {
-          var newState;
-          do {
-            newState = getRandomInteger(
-              -1000,
-              1000 + Object.keys(this.ops).length * 5
-            );
-          } while (this.statesUsed.has(newState));
-
-          ok(!isNaN(newState));
-
-          this.statesUsed.add(newState);
-          this.ops[operator] = newState;
-          this.log(operator, `calc(${newState}, left, right)`);
-        }
-
-        this.replace(
-          object,
-          CallExpression(Identifier(this.calculatorFn), [
-            Literal(this.ops[operator]),
-            { ...object.left },
-            { ...object.right },
-          ])
-        );
-      };
-    }
+
+      this.replace(
+        object,
+        CallExpression(Identifier(this.calculatorFn), [
+          Literal(this.ops[operator]),
+          object.left,
+          object.right,
+        ])
+      );
+    };
   }
 }