js-confuser 1.7.1 → 1.7.3

package/src/transforms/extraction/objectExtraction.ts

@@ -1,19 +1,7 @@
 import Transform from "../transform";
 import { walk } from "../../traverse";
-import {
-  Node,
-  Location,
-  Identifier,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import {
-  clone,
-  deleteDeclaration,
-  getVarContext,
-  isVarContext,
-  prepend,
-} from "../../util/insert";
+import { Node, Location, Identifier, VariableDeclarator } from "../../util/gen";
+import { getVarContext, isVarContext } from "../../util/insert";
 import { ObfuscateOrder } from "../../order";
 import { getIdentifierInfo } from "../../util/identifiers";
 import { isValidIdentifier } from "../../util/compare";
@@ -316,8 +304,9 @@ export default class ObjectExtraction extends Transform {
             ...variableDeclarators
           );
 
+          // const can only be safely changed to let
           if (declaration.kind === "const") {
-            declaration.kind = "var";
+            declaration.kind = "let";
           }
 
           // update all identifiers that pointed to the old object

package/src/transforms/flatten.ts

@@ -1,5 +1,9 @@
 import { ok } from "assert";
-import { noRenameVariablePrefix, reservedIdentifiers } from "../constants";
+import {
+  noRenameVariablePrefix,
+  predictableFunctionTag,
+  reservedIdentifiers,
+} from "../constants";
 import { ObfuscateOrder } from "../order";
 import { walk } from "../traverse";
 import {
@@ -35,6 +39,7 @@ import {
 import { shuffle } from "../util/random";
 import Transform from "./transform";
 import { FunctionLengthTemplate } from "../templates/functionLength";
+import { ObjectDefineProperty } from "../templates/globals";
 
 /**
  * Flatten takes functions and isolates them from their original scope, and brings it to the top level of the program.
@@ -235,7 +240,11 @@ export default class Flatten extends Transform {
         return;
       }
 
-      var newFnName = this.getPlaceholder() + "_flat_" + currentFnName;
+      var newFnName =
+        this.getPlaceholder() +
+        "_flat_" +
+        currentFnName +
+        predictableFunctionTag;
       var flatObjectName = this.getPlaceholder() + "_flat_object";
 
       const getFlatObjectMember = (propertyName: string) => {
@@ -498,15 +507,21 @@ export default class Flatten extends Transform {
       // Preserve function.length property
       var originalFunctionLength = computeFunctionLength(object.params);
 
-      object.params = [SpreadElement(Identifier(argumentsName))];
+      object.params = [RestElement(Identifier(argumentsName))];
 
-      if (originalFunctionLength !== 0) {
+      if (this.options.preserveFunctionLength && originalFunctionLength !== 0) {
         if (!this.functionLengthName) {
           this.functionLengthName = this.getPlaceholder();
 
           prepend(
             parents[parents.length - 1] || object,
-            FunctionLengthTemplate.single({ name: this.functionLengthName })
+            FunctionLengthTemplate.single({
+              name: this.functionLengthName,
+              ObjectDefineProperty: this.createInitVariable(
+                ObjectDefineProperty,
+                parents
+              ),
+            })
           );
         }
 

package/src/transforms/identifier/globalAnalysis.ts

@@ -1,5 +1,6 @@
 import { reservedKeywords } from "../../constants";
 import { Location, Node } from "../../util/gen";
+import { isJSConfuserVar } from "../../util/guard";
 import { getIdentifierInfo } from "../../util/identifiers";
 import Transform from "../transform";
 
@@ -43,10 +44,26 @@ export default class GlobalAnalysis extends Transform {
       return;
     }
 
+    if (isJSConfuserVar(parents)) {
+      delete this.globals[object.name];
+      this.notGlobals.add(object.name);
+      return;
+    }
+
     // Cannot be defined or overridden
     if (info.spec.isDefined || info.spec.isModified) {
-      delete this.globals[object.name];
+      if (info.spec.isModified) {
+        // Only direct overwrites should be considered
+        // Changing object properties is allowed
+        if (
+          parents[0].type === "MemberExpression" &&
+          parents[0].object === object
+        ) {
+          return;
+        }
+      }
 
+      delete this.globals[object.name];
       this.notGlobals.add(object.name);
       return;
     }

package/src/transforms/identifier/globalConcealing.ts

@@ -22,9 +22,15 @@ import {
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
 import { chance, getRandomInteger } from "../../util/random";
-import { reservedIdentifiers } from "../../constants";
+import {
+  predictableFunctionTag,
+  reservedIdentifiers,
+  variableFunctionName,
+} from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
 import GlobalAnalysis from "./globalAnalysis";
+import { createGetGlobalTemplate } from "../../templates/bufferToString";
+import { isJSConfuserVar } from "../../util/guard";
 
 /**
  * Global Concealing hides global variables being accessed.
@@ -33,6 +39,12 @@ import GlobalAnalysis from "./globalAnalysis";
  */
 export default class GlobalConcealing extends Transform {
   globalAnalysis: GlobalAnalysis;
+  ignoreGlobals = new Set([
+    "require",
+    "__dirname",
+    "eval",
+    variableFunctionName,
+  ]);
 
   constructor(o) {
     super(o, ObfuscateOrder.GlobalConcealing);
@@ -52,7 +64,9 @@ export default class GlobalConcealing extends Transform {
         delete globals[del];
       });
 
-      delete globals["require"];
+      for (var varName of this.ignoreGlobals) {
+        delete globals[varName];
+      }
 
       reservedIdentifiers.forEach((x) => {
         delete globals[x];
@@ -69,63 +83,114 @@ export default class GlobalConcealing extends Transform {
       });
 
       if (Object.keys(globals).length > 0) {
-        var used = new Set();
+        var usedStates = new Set<number>();
 
         // Make getter function
 
         // holds "window" or "global"
         var globalVar = this.getPlaceholder();
 
-        // holds outermost "this"
-        var thisVar = this.getPlaceholder();
-
-        // "window" or "global" in node
-        var global =
-          this.options.globalVariables.values().next().value || "window";
-        var alternateGlobal = global === "window" ? "global" : "window";
-
-        var getGlobalVariableFnName = this.getPlaceholder();
-        var getThisVariableFnName = this.getPlaceholder();
+        var getGlobalVariableFnName =
+          this.getPlaceholder() + predictableFunctionTag;
 
         // Returns global variable or fall backs to `this`
-        var getGlobalVariableFn = Template(`
-        var ${getGlobalVariableFnName} = function(){
-          try {
-            return ${global} || ${alternateGlobal} || (new Function("return this"))();
-          } catch (e){
-            return ${getThisVariableFnName}["call"](this);
-          }
-        }`).single();
-
-        var getThisVariableFn = Template(`
-        var ${getThisVariableFnName} = function(){
-          try {
-            return this;
-          } catch (e){
-            return null;
-          }
-        }`).single();
+        var getGlobalVariableFn = createGetGlobalTemplate(
+          this,
+          object,
+          parents
+        ).compile({
+          getGlobalFnName: getGlobalVariableFnName,
+        });
 
         // 2. Replace old accessors
-        var globalFn = this.getPlaceholder();
+        var globalFn = this.getPlaceholder() + predictableFunctionTag;
 
         var newNames: { [globalVarName: string]: number } = Object.create(null);
 
         Object.keys(globals).forEach((name) => {
           var locations: Location[] = globals[name];
-          var state;
+          var state: number;
           do {
-            state = getRandomInteger(-1000, 1000 + used.size);
-          } while (used.has(state));
-          used.add(state);
+            state = getRandomInteger(-1000, 1000 + usedStates.size);
+          } while (usedStates.has(state));
+          usedStates.add(state);
 
           newNames[name] = state;
 
-          locations.forEach(([node, parents]) => {
-            this.replace(
-              node,
-              CallExpression(Identifier(globalFn), [Literal(state)])
-            );
+          locations.forEach(([node, p]) => {
+            if (p.find((x) => x.$multiTransformSkip)) {
+              return;
+            }
+
+            var newExpression = CallExpression(Identifier(globalFn), [
+              Literal(state),
+            ]);
+
+            this.replace(node, newExpression);
+
+            if (
+              this.options.lock?.tamperProtection &&
+              this.lockTransform.nativeFunctionName
+            ) {
+              var isMemberExpression = false;
+              var nameAndPropertyPath = [name];
+              var callExpression: Node;
+
+              var index = 0;
+              do {
+                if (p[index].type === "CallExpression") {
+                  callExpression = p[index];
+                  break;
+                }
+
+                var memberExpression = p[index];
+                if (memberExpression.type !== "MemberExpression") return;
+                var property = memberExpression.property;
+                var stringValue =
+                  property.type === "Literal"
+                    ? property.value
+                    : memberExpression.computed
+                    ? null
+                    : property.type === "Identifier"
+                    ? property.name
+                    : null;
+
+                if (!stringValue) return;
+
+                isMemberExpression = true;
+                nameAndPropertyPath.push(stringValue);
+                index++;
+              } while (index < p.length);
+
+              if (
+                !this.lockTransform.shouldTransformNativeFunction(
+                  nameAndPropertyPath
+                )
+              )
+                return;
+
+              if (callExpression && callExpression.type === "CallExpression") {
+                if (isMemberExpression) {
+                  callExpression.callee = CallExpression(
+                    Identifier(this.lockTransform.nativeFunctionName),
+                    [
+                      callExpression.callee.object,
+                      callExpression.callee.computed
+                        ? callExpression.callee.property
+                        : Literal(
+                            callExpression.callee.property.name ||
+                              callExpression.callee.property.value
+                          ),
+                    ]
+                  );
+                } else {
+                  callExpression.callee = CallExpression(
+                    Identifier(this.lockTransform.nativeFunctionName),
+                    [{ ...callExpression.callee }]
+                  );
+                }
+              }
+            }
           });
         });
 
@@ -136,10 +201,10 @@ export default class GlobalConcealing extends Transform {
             do {
               state = getRandomInteger(
                 0,
-                1000 + used.size + this.options.globalVariables.size * 100
+                1000 + usedStates.size + this.options.globalVariables.size * 100
               );
-            } while (used.has(state));
-            used.add(state);
+            } while (usedStates.has(state));
+            usedStates.add(state);
 
             newNames[name] = state;
           }
@@ -159,15 +224,7 @@ export default class GlobalConcealing extends Transform {
                 var code = newNames[name];
                 var body: Node[] = [
                   ReturnStatement(
-                    LogicalExpression(
-                      "||",
-                      MemberExpression(
-                        Identifier(globalVar),
-                        Literal(name),
-                        true
-                      ),
-                      MemberExpression(Identifier(thisVar), Literal(name), true)
-                    )
+                    MemberExpression(Identifier(globalVar), Literal(name), true)
                   ),
                 ];
                 if (chance(50)) {
@@ -180,7 +237,7 @@ export default class GlobalConcealing extends Transform {
                           "||",
                           Literal(name),
                           MemberExpression(
-                            Identifier(thisVar),
+                            Identifier(globalVar),
                             Literal(name),
                             true
                           )
@@ -195,18 +252,10 @@ export default class GlobalConcealing extends Transform {
               })
             ),
             ReturnStatement(
-              LogicalExpression(
-                "||",
-                MemberExpression(
-                  Identifier(globalVar),
-                  Identifier(returnName),
-                  true
-                ),
-                MemberExpression(
-                  Identifier(thisVar),
-                  Identifier(returnName),
-                  true
-                )
+              MemberExpression(
+                Identifier(globalVar),
+                Identifier(returnName),
+                true
               )
             ),
           ]
@@ -214,8 +263,8 @@ export default class GlobalConcealing extends Transform {
 
         var tempVar = this.getPlaceholder();
 
-        var variableDeclaration = Template(`
-        var ${globalVar}, ${thisVar};
+        var variableDeclaration = new Template(`
+        var ${globalVar};
         `).single();
 
         variableDeclaration.declarations.push(
@@ -226,11 +275,9 @@ export default class GlobalConcealing extends Transform {
                 FunctionExpression(
                   [],
                   [
-                    getGlobalVariableFn,
-                    getThisVariableFn,
-
-                    Template(
-                      `return ${thisVar} = ${getThisVariableFnName}["call"](this, ${globalFn}), ${globalVar} = ${getGlobalVariableFnName}["call"](this)`
+                    ...getGlobalVariableFn,
+                    new Template(
+                      `return ${globalVar} = ${getGlobalVariableFnName}["call"](this)`
                     ).single(),
                   ]
                 ),

package/src/transforms/identifier/movedDeclarations.ts

@@ -6,10 +6,21 @@ import {
   Identifier,
   Node,
   VariableDeclarator,
+  AssignmentPattern,
 } from "../../util/gen";
-import { isForInitialize, prepend } from "../../util/insert";
+import {
+  isForInitialize,
+  isFunction,
+  isStrictModeFunction,
+  prepend,
+} from "../../util/insert";
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
+import { choice } from "../../util/random";
+import { predictableFunctionTag } from "../../constants";
+import { isIndependent, isMoveable } from "../../util/compare";
+import { getFunctionParameters } from "../../util/identifiers";
+import { isLexicalScope } from "../../util/scope";
 
 /**
  * Defines all the names at the top of every lexical block.
@@ -33,35 +44,86 @@ export default class MovedDeclarations extends Transform {
       var forInitializeType = isForInitialize(object, parents);
 
       // Get the block statement or Program node
-      var blockIndex = parents.findIndex((x) => isBlock(x));
+      var blockIndex = parents.findIndex((x) => isLexicalScope(x));
       var block = parents[blockIndex];
-      var body = block.body;
-      var bodyObject = parents[blockIndex - 2] || object;
+      var body: Node[] =
+        block.type === "SwitchCase" ? block.consequent : block.body;
+      ok(Array.isArray(body), "No body array found.");
 
-      // Make sure in the block statement, and not already at the top of it
+      var bodyObject = parents[blockIndex - 2] || object;
       var index = body.indexOf(bodyObject);
-      if (index === -1 || index === 0) return;
 
-      var topVariableDeclaration;
-      if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
-        topVariableDeclaration = body[0];
+      var varName = object.declarations[0].id.name;
+      ok(typeof varName === "string");
+
+      var predictableFunctionIndex = parents.findIndex((x) => isFunction(x));
+      var predictableFunction = parents[predictableFunctionIndex];
+
+      var deleteStatement = false;
+
+      if (
+        predictableFunction &&
+        ((predictableFunction.id &&
+          predictableFunction.id.name.includes(predictableFunctionTag)) ||
+          predictableFunction[predictableFunctionTag]) && // Must have predictableFunctionTag in the name, or on object
+        predictableFunction[predictableFunctionTag] !== false && // If === false, the function is deemed not predictable
+        predictableFunction.params.length < 1000 && // Max 1,000 parameters
+        !predictableFunction.params.find((x) => x.type === "RestElement") && // Cannot add parameters after spread operator
+        !(
+          ["Property", "MethodDefinition"].includes(
+            parents[predictableFunctionIndex + 1]?.type
+          ) && parents[predictableFunctionIndex + 1]?.kind !== "init"
+        ) && // Preserve getter/setter methods
+        !getFunctionParameters(
+          predictableFunction,
+          parents.slice(predictableFunctionIndex)
+        ).find((entry) => entry[0].name === varName) // Ensure not duplicate param name
+      ) {
+        // Use function f(..., x, y, z) to declare name
+
+        var value = object.declarations[0].init;
+        var isPredictablyComputed =
+          predictableFunction.body === block &&
+          !isStrictModeFunction(predictableFunction) &&
+          value &&
+          isIndependent(value, []) &&
+          isMoveable(value, [object.declarations[0], object, ...parents]);
+
+        var defineWithValue = isPredictablyComputed;
+
+        if (defineWithValue) {
+          predictableFunction.params.push(
+            AssignmentPattern(Identifier(varName), value)
+          );
+          object.declarations[0].init = null;
+          deleteStatement = true;
+        } else {
+          predictableFunction.params.push(Identifier(varName));
+        }
       } else {
-        topVariableDeclaration = {
-          type: "VariableDeclaration",
-          declarations: [],
-          kind: "var",
-        };
+        // Use 'var x, y, z' to declare name
 
-        prepend(block, topVariableDeclaration);
-      }
+        // Make sure in the block statement, and not already at the top of it
+        if (index === -1 || index === 0) return;
 
-      var varName = object.declarations[0].id.name;
-      ok(typeof varName === "string");
+        var topVariableDeclaration;
+        if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
+          topVariableDeclaration = body[0];
+        } else {
+          topVariableDeclaration = {
+            type: "VariableDeclaration",
+            declarations: [],
+            kind: "var",
+          };
 
-      // Add `var x` at the top of the block
-      topVariableDeclaration.declarations.push(
-        VariableDeclarator(Identifier(varName))
-      );
+          prepend(block, topVariableDeclaration);
+        }
+
+        // Add `var x` at the top of the block
+        topVariableDeclaration.declarations.push(
+          VariableDeclarator(Identifier(varName))
+        );
+      }
 
       var assignmentExpression = AssignmentExpression(
         "=",
@@ -79,8 +141,12 @@ export default class MovedDeclarations extends Transform {
           this.replace(object, Identifier(varName));
         }
       } else {
-        // Replace `var x = value` to `x = value`
-        this.replace(object, ExpressionStatement(assignmentExpression));
+        if (deleteStatement && index !== -1) {
+          body.splice(index, 1);
+        } else {
+          // Replace `var x = value` to `x = value`
+          this.replace(object, ExpressionStatement(assignmentExpression));
+        }
       }
     };
   }

package/src/transforms/identifier/renameVariables.ts

@@ -1,7 +1,7 @@
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
 import { walk } from "../../traverse";
-import { Node } from "../../util/gen";
+import { Literal, Node } from "../../util/gen";
 import { getIdentifierInfo } from "../../util/identifiers";
 import {
   isVarContext,
@@ -15,6 +15,7 @@ import {
   noRenameVariablePrefix,
   placeholderVariablePrefix,
   reservedIdentifiers,
+  variableFunctionName,
 } from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
 import VariableAnalysis from "./variableAnalysis";
@@ -267,6 +268,20 @@ export default class RenameVariables extends Transform {
         }
       }
 
+      if (
+        parents[1] &&
+        parents[1].type === "CallExpression" &&
+        parents[1].arguments === parents[0]
+      ) {
+        if (
+          parents[1].callee.type === "Identifier" &&
+          parents[1].callee.name === variableFunctionName
+        ) {
+          this.replace(parents[1], Literal(newName));
+          return;
+        }
+      }
+
       // console.log(o.name, "->", newName);
       // 5. Update Identifier node's 'name' property
       object.name = newName;

package/src/transforms/lock/antiDebug.ts

@@ -16,7 +16,7 @@ import { getRandomInteger } from "../../util/random";
 import Transform from "../transform";
 import Lock from "./lock";
 
-var DevToolsDetection = Template(
+var DevToolsDetection = new Template(
   `
   try {
     if ( setInterval ) {
@@ -52,7 +52,7 @@ export default class AntiDebug extends Transform {
       fnName,
       [],
       [
-        ...Template(`
+        ...new Template(`
       var ${startTimeName} = new Date();
       debugger;
       var ${endTimeName} = new Date();