js-confuser 1.7.1 → 1.7.3

package/src/transforms/lock/integrity.ts

@@ -42,7 +42,7 @@ function cyrb53(str, seed = 0) {
 }
 
 // In template form to be inserted into code
-const HashTemplate = Template(`
+const HashTemplate = new Template(`
 function {name}(str, seed) {
   var h1 = 0xdeadbeef ^ seed;
   var h2 = 0x41c6ce57 ^ seed;
@@ -57,7 +57,7 @@ function {name}(str, seed) {
 };`);
 
 // Math.imul polyfill for ES5
-const ImulTemplate = Template(`
+const ImulTemplate = new Template(`
 var {name} = Math.imul || function(opA, opB){
   opB |= 0; // ensure that opB is an integer. opA will automatically be coerced.
   // floating points give us 53 bits of precision to work with plus 1 sign bit
@@ -73,7 +73,7 @@ var {name} = Math.imul || function(opA, opB){
 };`);
 
 // Simple function that returns .toString() value with spaces replaced out
-const StringTemplate = Template(`
+const StringTemplate = new Template(`
   function {name}(x){
     return x.toString().replace(/ |\\n|;|,|\\{|\\}|\\(|\\)|\\.|\\[|\\]/g, "");
   }
@@ -128,7 +128,7 @@ export default class Integrity extends Transform {
         var imulName = this.getPlaceholder();
         var imulVariableDeclaration = ImulTemplate.single({ name: imulName });
 
-        imulVariableDeclaration.$dispatcherSkip = true;
+        imulVariableDeclaration.$multiTransformSkip = true;
 
         this.imulFn = imulVariableDeclaration._hiddenId = Identifier(imulName);
         hashingUtils.push(imulVariableDeclaration);
@@ -141,7 +141,7 @@ export default class Integrity extends Transform {
         this.hashFn = hashFunctionDeclaration._hiddenId = Identifier(hashName);
         hashingUtils.push(hashFunctionDeclaration);
 
-        hashFunctionDeclaration.$dispatcherSkip = true;
+        hashFunctionDeclaration.$multiTransformSkip = true;
 
         var stringName = this.getPlaceholder();
         var stringFunctionDeclaration = StringTemplate.single({
@@ -151,7 +151,7 @@ export default class Integrity extends Transform {
           Identifier(stringName);
         hashingUtils.push(stringFunctionDeclaration);
 
-        stringFunctionDeclaration.$dispatcherSkip = true;
+        stringFunctionDeclaration.$multiTransformSkip = true;
 
         var functionExpression = FunctionExpression([], clone(object.body));
 
@@ -159,7 +159,7 @@ export default class Integrity extends Transform {
           ExpressionStatement(CallExpression(functionExpression, [])),
         ];
 
-        object.$dispatcherSkip = true;
+        object.$multiTransformSkip = true;
 
         object._hiddenHashingUtils = hashingUtils;
 
@@ -211,7 +211,7 @@ export default class Integrity extends Transform {
           params: object.params || [],
           body: object.body || BlockStatement([]),
           expression: false,
-          $dispatcherSkip: true,
+          $multiTransformSkip: true,
         };
 
         var toString = compileJsSync(functionDeclaration, this.options);
@@ -231,9 +231,11 @@ export default class Integrity extends Transform {
         var ifStatement = IfStatement(
           BinaryExpression("==", Identifier(hashName), Literal(hash)),
           [
-            Template(`return {functionName}.apply(this, arguments)`).single({
-              functionName: functionName,
-            }),
+            new Template(`return {functionName}.apply(this, arguments)`).single(
+              {
+                functionName: functionName,
+              }
+            ),
           ]
         );
         if (

package/src/transforms/lock/lock.ts

@@ -20,11 +20,7 @@ import {
 } from "../../util/gen";
 import traverse, { getBlock, isBlock } from "../../traverse";
 import { choice, getRandomInteger } from "../../util/random";
-import {
-  CrashTemplate1,
-  CrashTemplate2,
-  CrashTemplate3,
-} from "../../templates/crash";
+import { CrashTemplate1, CrashTemplate2 } from "../../templates/crash";
 import { getBlockBody, getVarContext, prepend } from "../../util/insert";
 import Template from "../../templates/template";
 import { ObfuscateOrder } from "../../order";
@@ -33,6 +29,8 @@ import AntiDebug from "./antiDebug";
 import { getIdentifierInfo } from "../../util/identifiers";
 import { isLoop, isValidIdentifier } from "../../util/compare";
 import { ok } from "assert";
+import { variableFunctionName } from "../../constants";
+import { IndexOfTemplate } from "../../templates/core";
 
 /**
  * Applies browser & date locks.
@@ -48,8 +46,44 @@ export default class Lock extends Transform {
    */
   counterMeasuresActivated: string;
 
+  /**
+   * The name of the native function that is used to check runtime calls for tampering
+   */
+  nativeFunctionName: string;
+
   made: number;
 
+  shouldTransformNativeFunction(nameAndPropertyPath: string[]) {
+    if (!this.options.lock.tamperProtection) {
+      return false;
+    }
+
+    if (typeof this.options.lock.tamperProtection === "function") {
+      return this.options.lock.tamperProtection(nameAndPropertyPath.join("."));
+    }
+
+    if (
+      this.options.target === "browser" &&
+      nameAndPropertyPath.length === 1 &&
+      nameAndPropertyPath[0] === "fetch"
+    ) {
+      return true;
+    }
+
+    // TODO: Allow user to customize this behavior
+    var globalObject = typeof window !== "undefined" ? window : global;
+    var fn = globalObject;
+    for (var item of nameAndPropertyPath) {
+      fn = fn[item];
+      if (typeof fn === "undefined") return false;
+    }
+
+    var hasNativeCode =
+      typeof fn === "function" && ("" + fn).includes("[native code]");
+
+    return hasNativeCode;
+  }
+
   constructor(o) {
     super(o, ObfuscateOrder.Lock);
 
@@ -115,6 +149,77 @@ export default class Lock extends Transform {
     }
 
     super.apply(tree);
+
+    if (this.options.lock.tamperProtection) {
+      this.nativeFunctionName = this.getPlaceholder() + "_lockNative";
+
+      // Ensure program is not in strict mode
+      // Tamper Protection forces non-strict mode
+
+      var strictModeCheck = new Template(`
+        (function(){
+          function isStrictMode(){
+            try {
+              var arr = []
+              delete arr["length"]
+            } catch(e) {
+              return true;
+            }
+            return false;
+          }
+
+          if(isStrictMode()) {
+            {countermeasures}
+            ${this.nativeFunctionName} = undefined;
+          }
+        })()
+        `).single({
+        countermeasures: this.getCounterMeasuresCode(tree, []),
+      });
+
+      // $multiTransformSkip is used to prevent scoping between transformations
+      strictModeCheck.$multiTransformSkip = true;
+
+      prepend(tree, strictModeCheck);
+
+      var nativeFunctionCheck = new Template(`
+        function ${this.nativeFunctionName}() {
+          {IndexOfTemplate}
+        
+          function checkFunction(fn){
+            if (indexOf("" + fn, '{ [native code] }') === -1
+            ||
+            typeof Object.getOwnPropertyDescriptor(fn, "toString") !== "undefined"
+            ) {
+              {countermeasures}
+              return undefined
+            }
+
+            return fn;
+          }
+
+          var args = arguments
+          if(args.length === 1) {
+            return checkFunction(args[0]);
+          } else if (args.length === 2) {
+            var object = args[0];
+            var property = args[1];
+
+            var fn = object[property];
+            fn = checkFunction(fn);
+
+            return fn.bind(object);
+          }
+        }`).single({
+        IndexOfTemplate: IndexOfTemplate,
+        countermeasures: this.getCounterMeasuresCode(tree, []),
+      });
+
+      // $multiTransformSkip is used to prevent scoping between transformations
+      nativeFunctionCheck.$multiTransformSkip = true;
+
+      prepend(tree, nativeFunctionCheck);
+    }
   }
 
   getCounterMeasuresCode(object: Node, parents: Node[]): Node[] {
@@ -147,31 +252,18 @@ export default class Lock extends Transform {
                 Identifier(this.counterMeasuresActivated),
                 Literal(true)
               ),
-              CallExpression(Template(opt).single().expression, []),
+              CallExpression(new Template(opt).single().expression, []),
             ])
           )
         ),
       ];
     }
 
-    var type = choice(["crash", "exit"]);
-
-    switch (type) {
-      case "crash":
-        var varName = this.getPlaceholder();
-        return choice([CrashTemplate1, CrashTemplate2, CrashTemplate3]).compile(
-          {
-            var: varName,
-          }
-        );
-
-      case "exit":
-        if (this.options.target == "browser") {
-          return Template("document.documentElement.innerHTML = '';").compile();
-        }
-
-        return Template("process.exit()").compile();
-    }
+    // Default fallback to infinite loop
+    var varName = this.getPlaceholder();
+    return choice([CrashTemplate1, CrashTemplate2]).compile({
+      var: varName,
+    });
   }
 
   /**
@@ -281,7 +373,7 @@ export default class Lock extends Transform {
         case "selfDefending":
           // A very simple mechanism inspired from https://github.com/javascript-obfuscator/javascript-obfuscator/blob/master/src/custom-code-helpers/self-defending/templates/SelfDefendingNoEvalTemplate.ts
           // regExp checks for a newline, formatters add these
-          var callExpression = Template(
+          var callExpression = new Template(
             `
             (
               function(){
@@ -379,7 +471,7 @@ export default class Lock extends Transform {
           break;
 
         case "osLock":
-          var navigatorUserAgent = Template(
+          var navigatorUserAgent = new Template(
             `window.navigator.userAgent.toLowerCase()`
           ).single().expression;
 
@@ -404,7 +496,7 @@ export default class Lock extends Transform {
                 this.iosDetectFn = this.getPlaceholder();
                 prepend(
                   parents[parents.length - 1] || object,
-                  Template(`function ${this.iosDetectFn}() {
+                  new Template(`function ${this.iosDetectFn}() {
                   return [
                     'iPad Simulator',
                     'iPhone Simulator',
@@ -426,7 +518,7 @@ export default class Lock extends Transform {
               var platformName =
                 { windows: "win32", osx: "darwin", ios: "darwin" }[osName] ||
                 osName;
-              thisTest = Template(
+              thisTest = new Template(
                 `require('os').platform()==="${platformName}"`
               ).single().expression;
             }
@@ -443,7 +535,7 @@ export default class Lock extends Transform {
           break;
 
         case "browserLock":
-          var navigatorUserAgent = Template(
+          var navigatorUserAgent = new Template(
             `window.navigator.userAgent.toLowerCase()`
           ).single().expression;
 
@@ -462,7 +554,7 @@ export default class Lock extends Transform {
             );
 
             if (browserName === "safari") {
-              thisTest = Template(
+              thisTest = new Template(
                 `/^((?!chrome|android).)*safari/i.test(navigator.userAgent)`
               ).single().expression;
             }

package/src/transforms/minify.ts

@@ -29,6 +29,8 @@ import { walk, isBlock } from "../traverse";
 import { ok } from "assert";
 import { isLexicalScope } from "../util/scope";
 import Template from "../templates/template";
+import { ObjectDefineProperty } from "../templates/globals";
+import { getIdentifierInfo } from "../util/identifiers";
 
 /**
  * Basic transformations to reduce code size.
@@ -258,26 +260,35 @@ export default class Minify extends Transform {
 
             append(
               parents[parents.length - 1] || object,
-              Template(`
-            function ${this.arrowFunctionName}(arrowFn, functionLength){
+              new Template(`
+            function ${this.arrowFunctionName}(arrowFn, functionLength = 0){
               var functionObject = function(){ return arrowFn(...arguments) };
 
-              Object["defineProperty"](functionObject, "length", {
-                "value": functionLength,
-                "configurable": true
-              });
-
-              return functionObject;
+              ${
+                this.options.preserveFunctionLength
+                  ? `return {ObjectDefineProperty}(functionObject, "length", {
+                  "value": functionLength,
+                  "configurable": true
+                });`
+                  : `return functionObject`
+              }
+           
             }
-            `).single()
+            `).single({
+                ObjectDefineProperty: this.options.preserveFunctionLength
+                  ? this.createInitVariable(ObjectDefineProperty, parents)
+                  : undefined,
+              })
             );
           }
 
           const wrap = (object: Node) => {
-            return CallExpression(Identifier(this.arrowFunctionName), [
-              clone(object),
-              Literal(computeFunctionLength(object.params)),
-            ]);
+            var args: Node[] = [clone(object)];
+            var fnLength = computeFunctionLength(object.params);
+            if (this.options.preserveFunctionLength && fnLength != 0) {
+              args.push(Literal(fnLength));
+            }
+            return CallExpression(Identifier(this.arrowFunctionName), args);
           };
 
           if (object.type == "FunctionExpression") {
@@ -619,6 +630,7 @@ export default class Minify extends Transform {
 
       if (
         object.id.type == "ObjectPattern" &&
+        object.init &&
         object.init.type == "ObjectExpression"
       ) {
         if (
@@ -673,6 +685,9 @@ export default class Minify extends Transform {
     }
     if (object.type == "Identifier") {
       return () => {
+        var info = getIdentifierInfo(object, parents);
+        if (info.spec.isDefined || info.spec.isModified) return;
+
         if (object.name == "undefined" && !isForInitialize(object, parents)) {
           this.replaceIdentifierOrLiteral(
             object,

package/src/transforms/opaquePredicates.ts

@@ -78,7 +78,7 @@ export default class OpaquePredicates extends Transform {
   match(object: Node, parents: Node[]) {
     return (
       (isTestExpression(object, parents) || object.type == "SwitchCase") &&
-      !parents.find((x) => x.$dispatcherSkip || x.type == "AwaitExpression")
+      !parents.find((x) => x.$multiTransformSkip || x.type == "AwaitExpression")
     );
   }
 
@@ -146,7 +146,7 @@ export default class OpaquePredicates extends Transform {
                 Identifier(prop),
                 FunctionExpression(
                   [AssignmentPattern(Identifier(paramName), Literal("length"))],
-                  Template(`
+                  new Template(`
                   if ( !${this.predicateName}.${arrayProp}[0] ) {
                     ${this.predicateName}.${arrayProp}.push(${getRandomInteger(
                     -100,

package/src/transforms/preparation.ts

@@ -13,6 +13,7 @@ import { clone, getFunction } from "../util/insert";
 import { getIdentifierInfo } from "../util/identifiers";
 import { isLoop } from "../util/compare";
 import { ExitCallback, walk } from "../traverse";
+import { variableFunctionName } from "../constants";
 
 /**
  * Preparation arranges the user's code into an AST the obfuscator can easily transform.
@@ -49,6 +50,21 @@ export default class Preparation extends Transform {
       return this.transformExplicitIdentifiers(object, parents);
     }
 
+    // __JS_CONFUSER_VAR__ - Remove when Rename Variables is disabled
+    if (
+      object.type === "CallExpression" &&
+      object.callee.type === "Identifier" &&
+      object.callee.name === variableFunctionName
+    ) {
+      if (object.arguments[0].type === "Identifier") {
+        if (!this.obfuscator.transforms["RenameVariables"]) {
+          return () => {
+            this.replace(object, Literal(object.arguments[0].name));
+          };
+        }
+      }
+    }
+
     // ExplicitDeclarations
     if (object.type === "VariableDeclaration") {
       return this.transformExplicitDeclarations(object, parents);