js-confuser 1.7.1 → 1.7.2

package/src/transforms/identifier/globalConcealing.ts

@@ -22,9 +22,10 @@ import {
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
 import { chance, getRandomInteger } from "../../util/random";
-import { reservedIdentifiers } from "../../constants";
+import { predictableFunctionTag, reservedIdentifiers } from "../../constants";
 import { ComputeProbabilityMap } from "../../probability";
 import GlobalAnalysis from "./globalAnalysis";
+import { GetGlobalTemplate } from "../../templates/bufferToString";
 
 /**
  * Global Concealing hides global variables being accessed.
@@ -33,6 +34,7 @@ import GlobalAnalysis from "./globalAnalysis";
  */
 export default class GlobalConcealing extends Transform {
   globalAnalysis: GlobalAnalysis;
+  ignoreGlobals = new Set(["require", "__dirname", "eval"]);
 
   constructor(o) {
     super(o, ObfuscateOrder.GlobalConcealing);
@@ -52,7 +54,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,55 +73,33 @@ 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 = GetGlobalTemplate.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;
 
@@ -136,10 +118,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 +141,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 +154,7 @@ export default class GlobalConcealing extends Transform {
                           "||",
                           Literal(name),
                           MemberExpression(
-                            Identifier(thisVar),
+                            Identifier(globalVar),
                             Literal(name),
                             true
                           )
@@ -195,18 +169,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
               )
             ),
           ]
@@ -215,7 +181,7 @@ export default class GlobalConcealing extends Transform {
         var tempVar = this.getPlaceholder();
 
         var variableDeclaration = Template(`
-        var ${globalVar}, ${thisVar};
+        var ${globalVar};
         `).single();
 
         variableDeclaration.declarations.push(
@@ -226,11 +192,9 @@ export default class GlobalConcealing extends Transform {
                 FunctionExpression(
                   [],
                   [
-                    getGlobalVariableFn,
-                    getThisVariableFn,
-
+                    ...getGlobalVariableFn,
                     Template(
-                      `return ${thisVar} = ${getThisVariableFnName}["call"](this, ${globalFn}), ${globalVar} = ${getGlobalVariableFnName}["call"](this)`
+                      `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/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.
@@ -259,25 +261,34 @@ export default class Minify extends Transform {
             append(
               parents[parents.length - 1] || object,
               Template(`
-            function ${this.arrowFunctionName}(arrowFn, functionLength){
+            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/rgf.ts

@@ -1,13 +1,16 @@
 import { compileJsSync } from "../compiler";
-import { reservedIdentifiers } from "../constants";
+import { predictableFunctionTag, reservedIdentifiers } from "../constants";
 import Obfuscator from "../obfuscator";
 import { ObfuscateOrder } from "../order";
 import { ComputeProbabilityMap } from "../probability";
+import { FunctionLengthTemplate } from "../templates/functionLength";
+import { ObjectDefineProperty } from "../templates/globals";
 import { walk } from "../traverse";
 import {
   ArrayExpression,
   BlockStatement,
   CallExpression,
+  ExpressionStatement,
   Identifier,
   Literal,
   MemberExpression,
@@ -19,7 +22,11 @@ import {
   VariableDeclarator,
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
-import { prepend, getDefiningContext } from "../util/insert";
+import {
+  prepend,
+  getDefiningContext,
+  computeFunctionLength,
+} from "../util/insert";
 import Integrity from "./lock/integrity";
 import Transform from "./transform";
 
@@ -38,6 +45,16 @@ export default class RGF extends Transform {
   // The name of the array holding all the `new Function` expressions
   arrayExpressionName: string;
 
+  functionLengthName: string;
+
+  getFunctionLengthName(parents: Node[]) {
+    if (!this.functionLengthName) {
+      this.functionLengthName = this.getPlaceholder();
+    }
+
+    return this.functionLengthName;
+  }
+
   constructor(o) {
     super(o, ObfuscateOrder.RGF);
 
@@ -60,6 +77,19 @@ export default class RGF extends Transform {
         )
       );
     }
+
+    // The function.length helper function must be placed last
+    if (this.functionLengthName) {
+      prepend(
+        tree,
+        FunctionLengthTemplate.single({
+          name: this.functionLengthName,
+          ObjectDefineProperty: this.createInitVariable(ObjectDefineProperty, [
+            tree,
+          ]),
+        })
+      );
+    }
   }
 
   match(object, parents) {
@@ -141,6 +171,7 @@ export default class RGF extends Transform {
       walk(object, parents, (o, p) => {
         if (
           o.type === "Identifier" &&
+          o.name !== this.arrayExpressionName &&
           !reservedIdentifiers.has(o.name) &&
           !this.options.globalVariables.has(o.name)
         ) {
@@ -226,9 +257,26 @@ export default class RGF extends Transform {
         generator: false,
       };
 
+      // The new program will look like this
+      // new Function(`
+      //  var rgf_array = this[0]
+      //  function greet(message){
+      //      console.log(message)
+      //  }
+      //  return greet.apply(this[1], arguments)
+      // `)
+      //
+      // And called like
+      // f.apply([ rgf_array, this ], arguments)
       var tree = {
         type: "Program",
         body: [
+          VariableDeclaration(
+            VariableDeclarator(
+              this.arrayExpressionName,
+              MemberExpression(ThisExpression(), Literal(0))
+            )
+          ),
           embeddedFunction,
           ReturnStatement(
             CallExpression(
@@ -237,7 +285,10 @@ export default class RGF extends Transform {
                 Literal("apply"),
                 true
               ),
-              [ThisExpression(), Identifier("arguments")]
+              [
+                MemberExpression(ThisExpression(), Literal(1)),
+                Identifier("arguments"),
+              ]
             )
           ),
         ],
@@ -261,12 +312,14 @@ export default class RGF extends Transform {
       this.arrayExpressionElements.push(newFunctionExpression);
 
       // The member expression to retrieve this function
-      var memberExpression = MemberExpression(
+      var memberExpression: Node = MemberExpression(
         Identifier(this.arrayExpressionName),
         Literal(newFunctionExpressionIndex),
         true
       );
 
+      var originalFunctionLength = computeFunctionLength(object.params);
+
       // Replace based on type
 
       // (1) Function Declaration:
@@ -276,19 +329,55 @@ export default class RGF extends Transform {
           ReturnStatement(
             CallExpression(
               MemberExpression(memberExpression, Literal("apply"), true),
-              [ThisExpression(), Identifier("arguments")]
+              [
+                ArrayExpression([
+                  Identifier(this.arrayExpressionName),
+                  ThisExpression(),
+                ]),
+                Identifier("arguments"),
+              ]
             )
           ),
         ]);
 
         // The parameters are no longer needed ('arguments' is used to capture them)
         object.params = [];
+
+        // The function is no longer guaranteed to not have extraneous parameters passed in
+        object[predictableFunctionTag] = false;
+
+        if (
+          this.options.preserveFunctionLength &&
+          originalFunctionLength !== 0
+        ) {
+          var body = parents[0] as unknown as Node[];
+
+          body.splice(
+            body.indexOf(object),
+            0,
+            ExpressionStatement(
+              CallExpression(Identifier(this.getFunctionLengthName(parents)), [
+                Identifier(object.id.name),
+                Literal(originalFunctionLength),
+              ])
+            )
+          );
+        }
         return;
       }
 
       // (2) Function Expression:
       // - Replace expression with member expression pointing to new function
       if (object.type === "FunctionExpression") {
+        if (
+          this.options.preserveFunctionLength &&
+          originalFunctionLength !== 0
+        ) {
+          memberExpression = CallExpression(
+            Identifier(this.getFunctionLengthName(parents)),
+            [memberExpression, Literal(originalFunctionLength)]
+          );
+        }
         this.replace(object, memberExpression);
         return;
       }

package/src/transforms/stack.ts

@@ -1,7 +1,7 @@
 import { ok } from "assert";
 import { ObfuscateOrder } from "../order";
 import { ComputeProbabilityMap } from "../probability";
-import Template from "../templates/template";
+import Template, { ITemplate } from "../templates/template";
 import { walk } from "../traverse";
 import {
   AssignmentExpression,
@@ -16,6 +16,8 @@ import {
   RestElement,
   ReturnStatement,
   SequenceExpression,
+  VariableDeclaration,
+  VariableDeclarator,
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
 import {
@@ -32,6 +34,7 @@ import { chance, choice, getRandomInteger } from "../util/random";
 import Transform from "./transform";
 import { noRenameVariablePrefix } from "../constants";
 import { FunctionLengthTemplate } from "../templates/functionLength";
+import { ObjectDefineProperty } from "../templates/globals";
 
 export default class Stack extends Transform {
   mangledExpressionsMade: number;
@@ -497,12 +500,18 @@ export default class Stack extends Transform {
         Template(`${stackName}["length"] = ${startingSize}`).single()
       );
 
-      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
+              ),
+            })
           );
         }