js-confuser 1.5.5 → 1.5.7

package/src/transforms/lock/lock.ts

@@ -11,17 +11,12 @@ import {
   Literal,
   UnaryExpression,
   NewExpression,
-  FunctionDeclaration,
-  ReturnStatement,
   VariableDeclaration,
-  ObjectExpression,
-  Property,
-  ArrayExpression,
-  FunctionExpression,
   ThisExpression,
   VariableDeclarator,
   Location,
   LogicalExpression,
+  SequenceExpression,
 } from "../../util/gen";
 import traverse, { getBlock, isBlock } from "../../traverse";
 import { choice, getRandomInteger } from "../../util/random";
@@ -47,6 +42,12 @@ export default class Lock extends Transform {
   counterMeasuresNode: Location;
   iosDetectFn: string;
 
+  /**
+   * This is a boolean variable injected into the source code determining wether the countermeasures function has been called.
+   * This is used to prevent infinite loops from happening
+   */
+  counterMeasuresActivated: string;
+
   made: number;
 
   constructor(o) {
@@ -73,36 +74,32 @@ export default class Lock extends Transform {
       typeof this.options.lock.countermeasures === "string" &&
       isValidIdentifier(this.options.lock.countermeasures)
     ) {
-      var defined = new Set<string>();
       traverse(tree, (object, parents) => {
-        if (object.type == "Identifier") {
+        if (
+          object.type == "Identifier" &&
+          object.name === this.options.lock.countermeasures
+        ) {
           var info = getIdentifierInfo(object, parents);
           if (info.spec.isDefined) {
-            defined.add(object.name);
-            if (object.name === this.options.lock.countermeasures) {
-              if (this.counterMeasuresNode) {
+            if (this.counterMeasuresNode) {
+              throw new Error(
+                "Countermeasures function was already defined, it must have a unique name from the rest of your code"
+              );
+            } else {
+              var definingContext = getVarContext(parents[0], parents.slice(1));
+              if (definingContext != tree) {
                 throw new Error(
-                  "Countermeasures function was already defined, it must have a unique name from the rest of your code"
-                );
-              } else {
-                var definingContext = getVarContext(
-                  parents[0],
-                  parents.slice(1)
+                  "Countermeasures function must be defined at the global level"
                 );
-                if (definingContext != tree) {
-                  throw new Error(
-                    "Countermeasures function must be defined at the global level"
-                  );
-                }
-                var chain: Location = [object, parents];
-                if (info.isFunctionDeclaration) {
-                  chain = [parents[0], parents.slice(1)];
-                } else if (info.isVariableDeclaration) {
-                  chain = [parents[1], parents.slice(2)];
-                }
-
-                this.counterMeasuresNode = chain;
               }
+              var chain: Location = [object, parents];
+              if (info.isFunctionDeclaration) {
+                chain = [parents[0], parents.slice(1)];
+              } else if (info.isVariableDeclaration) {
+                chain = [parents[1], parents.slice(2)];
+              }
+
+              this.counterMeasuresNode = chain;
             }
           }
         }
@@ -120,7 +117,7 @@ export default class Lock extends Transform {
     super.apply(tree);
   }
 
-  getCounterMeasuresCode(): Node[] {
+  getCounterMeasuresCode(object: Node, parents: Node[]): Node[] {
     var opt = this.options.lock.countermeasures;
 
     if (opt === false) {
@@ -129,10 +126,30 @@ export default class Lock extends Transform {
 
     // Call function
     if (typeof opt === "string") {
+      if (!this.counterMeasuresActivated) {
+        this.counterMeasuresActivated = this.getPlaceholder();
+
+        prepend(
+          parents[parents.length - 1] || object,
+          VariableDeclaration(VariableDeclarator(this.counterMeasuresActivated))
+        );
+      }
+
       // Since Lock occurs before variable renaming, we are using the pre-obfuscated function name
       return [
         ExpressionStatement(
-          CallExpression(Template(opt).single().expression, [])
+          LogicalExpression(
+            "||",
+            Identifier(this.counterMeasuresActivated),
+            SequenceExpression([
+              AssignmentExpression(
+                "=",
+                Identifier(this.counterMeasuresActivated),
+                Literal(true)
+              ),
+              CallExpression(Template(opt).single().expression, []),
+            ])
+          )
         ),
       ];
     }
@@ -288,7 +305,7 @@ export default class Lock extends Transform {
           nodes.push(
             IfStatement(
               callExpression,
-              this.getCounterMeasuresCode() || [],
+              this.getCounterMeasuresCode(object, parents) || [],
               null
             )
           );
@@ -324,7 +341,11 @@ export default class Lock extends Transform {
             }
 
             nodes.push(
-              IfStatement(test, this.getCounterMeasuresCode() || [], null)
+              IfStatement(
+                test,
+                this.getCounterMeasuresCode(object, parents) || [],
+                null
+              )
             );
           }
 
@@ -338,7 +359,11 @@ export default class Lock extends Transform {
           );
 
           nodes.push(
-            IfStatement(test, this.getCounterMeasuresCode() || [], null)
+            IfStatement(
+              test,
+              this.getCounterMeasuresCode(object, parents) || [],
+              null
+            )
           );
 
           break;
@@ -351,7 +376,11 @@ export default class Lock extends Transform {
           );
 
           nodes.push(
-            IfStatement(test, this.getCounterMeasuresCode() || [], null)
+            IfStatement(
+              test,
+              this.getCounterMeasuresCode(object, parents) || [],
+              null
+            )
           );
 
           break;
@@ -359,6 +388,8 @@ export default class Lock extends Transform {
         case "context":
           var prop = choice(this.options.lock.context);
 
+          var code = this.getCounterMeasuresCode(object, parents) || [];
+
           // Todo: Alternative to `this`
           if (!this.globalVar) {
             offset = 1;
@@ -384,9 +415,7 @@ export default class Lock extends Transform {
             "!",
             MemberExpression(Identifier(this.globalVar), Literal(prop), true)
           );
-          nodes.push(
-            IfStatement(test, this.getCounterMeasuresCode() || [], null)
-          );
+          nodes.push(IfStatement(test, code, null));
 
           break;
 
@@ -397,6 +426,8 @@ export default class Lock extends Transform {
 
           ok(this.options.lock.osLock);
 
+          var code = this.getCounterMeasuresCode(object, parents) || [];
+
           this.options.lock.osLock.forEach((osName) => {
             var agentMatcher = {
               windows: "Win",
@@ -449,9 +480,7 @@ export default class Lock extends Transform {
           });
 
           test = UnaryExpression("!", { ...test });
-          nodes.push(
-            IfStatement(test, this.getCounterMeasuresCode() || [], null)
-          );
+          nodes.push(IfStatement(test, code, null));
           break;
 
         case "browserLock":
@@ -488,7 +517,11 @@ export default class Lock extends Transform {
 
           test = UnaryExpression("!", { ...test });
           nodes.push(
-            IfStatement(test, this.getCounterMeasuresCode() || [], null)
+            IfStatement(
+              test,
+              this.getCounterMeasuresCode(object, parents) || [],
+              null
+            )
           );
           break;
 
@@ -540,7 +573,11 @@ export default class Lock extends Transform {
               );
             }
             nodes.push(
-              IfStatement(test, this.getCounterMeasuresCode() || [], null)
+              IfStatement(
+                test,
+                this.getCounterMeasuresCode(object, parents) || [],
+                null
+              )
             );
           }
 

package/src/transforms/minify.ts

@@ -61,9 +61,10 @@ export default class Minify extends Transform {
 
         body.forEach((stmt, i) => {
           if (
-            stmt.type == "ReturnStatement" ||
-            stmt.type == "BreakStatement" ||
-            stmt.type == "ContinueStatement"
+            stmt.type === "ReturnStatement" ||
+            stmt.type === "BreakStatement" ||
+            stmt.type === "ContinueStatement" ||
+            stmt.type === "ThrowStatement"
           ) {
             if (earlyReturn > i + 1) {
               earlyReturn = i + 1;
@@ -156,7 +157,7 @@ export default class Minify extends Transform {
               ) {
                 lastDec = x;
               } else {
-                lastDec.declarations.push(...x.declarations);
+                lastDec.declarations.push(...clone(x.declarations));
                 remove.unshift(i);
               }
             } else {

package/src/transforms/preparation/preparation.ts

@@ -3,24 +3,11 @@
  */
 import Transform from "../transform";
 
-import {
-  BlockStatement,
-  Identifier,
-  LabeledStatement,
-  Literal,
-  Location,
-  Node,
-  ReturnStatement,
-} from "../../util/gen";
+import { BlockStatement, Literal, ReturnStatement } from "../../util/gen";
 import { ObfuscateOrder } from "../../order";
-import { getIndexDirect, clone, getFunction } from "../../util/insert";
-import { ok } from "assert";
+import { clone, getFunction } from "../../util/insert";
 import { getIdentifierInfo } from "../../util/identifiers";
-import { walk } from "../../traverse";
 import Label from "../label";
-import NameConflicts from "./nameConflicts";
-import AntiDestructuring from "../es5/antiDestructuring";
-import { OPERATOR_PRECEDENCE } from "../../precedence";
 import { isLoop } from "../../util/compare";
 
 /**
@@ -181,12 +168,6 @@ export default class Preparation extends Transform {
     this.before.push(new Label(o));
     this.before.push(new ExplicitIdentifiers(o));
     this.before.push(new ExplicitDeclarations(o));
-
-    if (this.options.es5) {
-      this.before.push(new AntiDestructuring(o));
-    }
-
-    // this.before.push(new NameConflicts(o));
   }
 
   match() {

package/src/transforms/rgf.ts

@@ -7,7 +7,10 @@ import Template from "../templates/template";
 import traverse, { walk } from "../traverse";
 import {
   ArrayExpression,
+  AssignmentExpression,
   CallExpression,
+  ConditionalExpression,
+  ExpressionStatement,
   FunctionExpression,
   Identifier,
   Literal,
@@ -27,7 +30,9 @@ import {
   isVarContext,
   isFunction,
   prepend,
+  getDefiningContext,
 } from "../util/insert";
+import { getRandomString } from "../util/random";
 import Transform from "./transform";
 
 /**
@@ -70,6 +75,8 @@ export default class RGF extends Transform {
       }[] = [];
       var queue: Location[] = [];
       var names = new Map<string, number>();
+      var referenceSignatures: { [name: string]: string } = {};
+
       var definingNodes = new Map<string, Node>();
 
       walk(contextObject, contextParents, (object, parents) => {
@@ -81,12 +88,63 @@ export default class RGF extends Transform {
           !object.generator &&
           getVarContext(parents[0], parents.slice(1)) === contextObject
         ) {
+          // Discard getter/setter methods
+          if (parents[0].type === "Property" && parents[0].value === object) {
+            if (
+              parents[0].method ||
+              parents[0].kind === "get" ||
+              parents[0].kind === "set"
+            ) {
+              return;
+            }
+          }
+
+          // Discard class methods
+          if (
+            parents[0].type === "MethodDefinition" &&
+            parents[0].value === object
+          ) {
+            return;
+          }
+
+          // Avoid applying to the countermeasures function
+          if (typeof this.options.lock?.countermeasures === "string") {
+            // function countermeasures(){...}
+            if (
+              object.type === "FunctionDeclaration" &&
+              object.id.type === "Identifier" &&
+              object.id.name === this.options.lock.countermeasures
+            ) {
+              return;
+            }
+
+            // var countermeasures = function(){...}
+            if (
+              parents[0].type === "VariableDeclarator" &&
+              parents[0].init === object &&
+              parents[0].id.type === "Identifier" &&
+              parents[0].id.name === this.options.lock.countermeasures
+            ) {
+              return;
+            }
+          }
+
           var defined = new Set<string>(),
             referenced = new Set<string>();
 
           var isBound = false;
 
-          walk(object.body, [object, ...parents], (o, p) => {
+          /**
+           * The fnTraverses serves two important purposes
+           *
+           * - Identify all the variables referenced and defined here
+           * - Identify is the 'this' keyword is used anywhere
+           *
+           * @param o
+           * @param p
+           * @returns
+           */
+          const fnTraverser = (o, p) => {
             if (
               o.type == "Identifier" &&
               !reservedIdentifiers.has(o.name) &&
@@ -96,7 +154,7 @@ export default class RGF extends Transform {
               if (!info.spec.isReferenced) {
                 return;
               }
-              if (info.spec.isDefined) {
+              if (info.spec.isDefined && getDefiningContext(o, p) === object) {
                 defined.add(o.name);
               } else {
                 referenced.add(o.name);
@@ -106,7 +164,10 @@ export default class RGF extends Transform {
             if (o.type == "ThisExpression" || o.type == "Super") {
               isBound = true;
             }
-          });
+          };
+
+          walk(object.params, [object, ...parents], fnTraverser);
+          walk(object.body, [object, ...parents], fnTraverser);
 
           if (!isBound) {
             defined.forEach((identifier) => {
@@ -177,6 +238,8 @@ export default class RGF extends Transform {
             var index = names.size;
 
             names.set(object.id.name, index);
+            referenceSignatures[index] = getRandomString(10);
+
             definingNodes.set(object.id.name, object.id);
           }
         }
@@ -186,7 +249,8 @@ export default class RGF extends Transform {
         return;
       }
 
-      var referenceArray = this.generateIdentifier();
+      // An array containing all the function declarations
+      var referenceArray = "_" + getRandomString(10);
 
       walk(contextObject, contextParents, (o, p) => {
         if (o.type == "Identifier" && !reservedIdentifiers.has(o.name)) {
@@ -204,27 +268,50 @@ export default class RGF extends Transform {
                 if (pointingTo == shouldBe) {
                   this.log(o.name, "->", `${referenceArray}[${index}]`);
 
-                  this.replace(
-                    o,
-                    FunctionExpression(
-                      [],
-                      [
-                        ReturnStatement(
-                          CallExpression(
-                            MemberExpression(
-                              Identifier(referenceArray),
-                              Literal(index),
-                              true
-                            ),
-                            [
+                  var memberExpression = MemberExpression(
+                    Identifier(referenceArray),
+                    Literal(index),
+                    true
+                  );
+
+                  // Allow re-assignment to the RGF function
+                  if (
+                    p[0] &&
+                    p[0].type === "AssignmentExpression" &&
+                    p[0].left === o
+                  ) {
+                    // fn = ...
+
+                    this.replace(o, memberExpression);
+                  } else {
+                    // fn()
+                    // fn
+
+                    // In most cases the identifier is being used like this (call expression, or referenced to be called later)
+                    // Replace it with a simple wrapper function that will pass on the reference array
+
+                    var conditionalExpression = ConditionalExpression(
+                      Template(
+                        `typeof ${referenceArray}[${index}] === "function" && ${referenceArray}[${index}]["${
+                          referenceSignatures[index] || "_"
+                        }"]`
+                      ).single().expression,
+                      FunctionExpression(
+                        [],
+                        [
+                          ReturnStatement(
+                            CallExpression(memberExpression, [
                               Identifier(referenceArray),
                               SpreadElement(Identifier("arguments")),
-                            ]
-                          )
-                        ),
-                      ]
-                    )
-                  );
+                            ])
+                          ),
+                        ]
+                      ),
+                      memberExpression
+                    );
+
+                    this.replace(o, conditionalExpression);
+                  }
                 }
               }
             }
@@ -243,6 +330,7 @@ export default class RGF extends Transform {
         var name = object?.id?.name;
         var hasName = !!name;
         var params = object.params.map((x) => x.name) || [];
+        var signature = referenceSignatures[names.get(name)];
 
         var embeddedName = name || this.getPlaceholder();
 
@@ -280,11 +368,11 @@ export default class RGF extends Transform {
               CallExpression(
                 MemberExpression(
                   Identifier(embeddedName),
-                  Identifier("call"),
-                  false
+                  Literal("call"),
+                  true
                 ),
                 [
-                  ThisExpression(),
+                  Identifier("undefined"),
                   SpreadElement(
                     Template(
                       `Array.prototype.slice.call(arguments, 1)`
@@ -322,8 +410,38 @@ export default class RGF extends Transform {
           Literal(toString),
         ]);
 
-        if (hasName) {
-          arrayExpression.elements[names.get(name)] = newFunction;
+        function applySignature(fn) {
+          if (!signature) {
+            return fn;
+          }
+
+          // This code marks the function object with a unique property
+          return CallExpression(
+            FunctionExpression(
+              [],
+              [
+                VariableDeclaration(VariableDeclarator("fn", fn)),
+                ExpressionStatement(
+                  AssignmentExpression(
+                    "=",
+                    MemberExpression(
+                      Identifier("fn"),
+                      Literal(signature),
+                      true
+                    ),
+                    Literal(true)
+                  )
+                ),
+                ReturnStatement(Identifier("fn")),
+              ]
+            ),
+            []
+          );
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          arrayExpression.elements[names.get(name)] =
+            applySignature(newFunction);
 
           if (Array.isArray(parents[0])) {
             parents[0].splice(parents[0].indexOf(object), 1);
@@ -336,7 +454,24 @@ export default class RGF extends Transform {
             );
           }
         } else {
-          this.replace(object, newFunction);
+          // The wrapper function passes the reference array around
+          var wrapperFunction = FunctionExpression(
+            [],
+            [
+              ReturnStatement(
+                CallExpression(
+                  MemberExpression(newFunction, Literal("call"), true),
+                  [
+                    Identifier("undefined"),
+                    Identifier(referenceArray),
+                    SpreadElement(Identifier("arguments")),
+                  ]
+                )
+              ),
+            ]
+          );
+
+          this.replace(object, applySignature(wrapperFunction));
         }
       });
     };

package/src/transforms/string/stringSplitting.ts

@@ -25,34 +25,11 @@ export default class StringSplitting extends Transform {
     this.vars = [];
   }
 
-  apply(tree) {
-    super.apply(tree);
-
-    if (this.vars.length) {
-      shuffle(this.adders);
-      shuffle(this.vars);
-
-      var body: Node[] = tree.body;
-
-      this.adders.forEach((nodes) => {
-        nodes.forEach((x) => body.unshift(x));
-      });
-
-      var variableDeclaration = {
-        type: "VariableDeclaration",
-        declarations: [],
-        kind: "var",
-      };
-      this.vars.forEach((node) => variableDeclaration.declarations.push(node));
-
-      body.unshift(variableDeclaration);
-    }
-  }
-
   match(object: Node, parents: Node[]) {
     return (
       object.type == "Literal" &&
       typeof object.value === "string" &&
+      object.value.length >= 8 &&
       !isModuleSource(object, parents) &&
       !isDirective(object, parents)
     );
@@ -87,7 +64,6 @@ export default class StringSplitting extends Transform {
       var last = chunks.pop();
       chunks.forEach((chunk, i) => {
         if (i == 0) {
-          ok(i == 0);
           parent = binaryExpression = BinaryExpression(
             "+",
             Literal(chunk),

package/test/transforms/lock/countermeasures.test.ts

@@ -80,3 +80,21 @@ test("Variant #4: Should work when countermeasures is variable declaration", asy
     }
   );
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/66
+test("Variant #5: Should work with RGF enabled", async () => {
+  await JsConfuser.obfuscate(
+    `
+  function myCountermeasuresFunction(){
+
+  }
+  `,
+    {
+      target: "node",
+      lock: {
+        countermeasures: "myCountermeasuresFunction",
+      },
+      rgf: true,
+    }
+  );
+});