js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/transforms/es5/es5.ts

@@ -1,149 +0,0 @@
-import Transform from "../transform";
-import {
-  Node,
-  Literal,
-  Identifier,
-  MemberExpression,
-  BlockStatement,
-  ReturnStatement,
-  CallExpression,
-  ThisExpression,
-} from "../../util/gen";
-import { clone, prepend } from "../../util/insert";
-import { isBlock, walk } from "../../traverse";
-import { ObfuscateOrder } from "../../order";
-import { ok } from "assert";
-import { reservedKeywords } from "../../constants";
-import AntiDestructuring from "./antiDestructuring";
-import AntiTemplate from "./antiTemplate";
-import AntiClass from "./antiClass";
-import AntiES6Object from "./antiES6Object";
-import AntiSpreadOperator from "./antiSpreadOperator";
-import { ES5Template } from "../../templates/es5";
-
-/**
- * `Const` and `Let` are not allowed in ES5.
- */
-class AntiConstLet extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return object.type == "VariableDeclaration" && object.kind != "var";
-  }
-
-  transform(object) {
-    object.kind = "var";
-  }
-}
-
-/**
- * Converts arrow functions
- */
-export class AntiArrowFunction extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object, parents) {
-    return object.type == "ArrowFunctionExpression";
-  }
-
-  transform(object, parents) {
-    return () => {
-      var usesThis = false;
-
-      if (object.body.type != "BlockStatement" && object.expression) {
-        object.body = BlockStatement([ReturnStatement(clone(object.body))]);
-        object.expression = false;
-      }
-
-      walk(object.body, [object, ...parents], (o, p) => {
-        if (p.filter((x) => isBlock(x))[0] == object.body) {
-          if (
-            o.type == "ThisExpression" ||
-            (o.type == "Identifier" && o.name == "this")
-          ) {
-            usesThis = true;
-          }
-        }
-      });
-
-      ok(object.body.type == "BlockStatement", "Should be a BlockStatement");
-      ok(Array.isArray(object.body.body), "Body should be an array");
-      ok(
-        !object.body.body.find((x) => Array.isArray(x)),
-        "All elements should be statements"
-      );
-
-      object.type = "FunctionExpression";
-      object.expression = false;
-
-      if (usesThis) {
-        this.objectAssign(
-          object,
-          CallExpression(
-            MemberExpression(clone(object), Identifier("bind"), false),
-            [ThisExpression()]
-          )
-        );
-      }
-    };
-  }
-}
-
-/**
- * The ES5 options aims to convert ES6 and up features down to ES5-compatible code.
- *
- * The obfuscator regularly adds ES6 code (variable destructuring, spread element, etc.)
- * This transformations goal is undo only these things.
- */
-export default class ES5 extends Transform {
-  constructor(o) {
-    super(o, ObfuscateOrder.ES5);
-
-    this.before.push(new AntiClass(o));
-    this.before.push(new AntiTemplate(o));
-    this.before.push(new AntiSpreadOperator(o));
-    this.before.push(new AntiES6Object(o));
-    this.before.push(new AntiArrowFunction(o));
-    this.before.push(new AntiDestructuring(o));
-    this.before.push(new AntiConstLet(o));
-  }
-
-  apply(tree: Node) {
-    super.apply(tree);
-
-    var nodesToAdd = ES5Template.compile();
-    prepend(tree, ...nodesToAdd);
-  }
-
-  // FixedExpressions
-  match(object: Node, parents: Node[]) {
-    return !!object.type;
-  }
-
-  transform(object: Node, parents: Node[]) {
-    return () => {
-      // Object.keyword -> Object["keyword"]
-      if (object.type == "MemberExpression") {
-        if (!object.computed && object.property.type == "Identifier") {
-          if (reservedKeywords.has(object.property.name)) {
-            object.property = Literal(object.property.name);
-            object.computed = true;
-          }
-        }
-      }
-
-      // { keyword: ... } -> { "keyword": ... }
-      if (object.type == "Property") {
-        if (!object.computed && object.key.type == "Identifier") {
-          if (reservedKeywords.has(object.key.name)) {
-            object.key = Literal(object.key.name);
-          }
-        }
-      }
-    };
-  }
-}

package/src/transforms/extraction/classExtraction.ts

@@ -1,168 +0,0 @@
-import { ok } from "assert";
-import { ExitCallback, getBlock, walk } from "../../traverse";
-import {
-  CallExpression,
-  FunctionDeclaration,
-  FunctionExpression,
-  Identifier,
-  Literal,
-  MemberExpression,
-  MethodDefinition,
-  Node,
-  ReturnStatement,
-  Super,
-  ThisExpression,
-} from "../../util/gen";
-import { isStringLiteral } from "../../util/guard";
-import { isClass, prepend } from "../../util/insert";
-import { getLexicalScope } from "../../util/scope";
-import Transform from "../transform";
-
-export default class ClassExtraction extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(object: Node, parents: Node[]): boolean {
-    return (
-      object.type === "ClassDeclaration" || object.type === "ClassExpression"
-    );
-  }
-
-  extractKeyString(property: Node): string | null {
-    if (property.key.type === "Identifier" && !property.key.computed) {
-      return property.key.name;
-    }
-
-    if (isStringLiteral(property.key)) {
-      return property.key.value;
-    }
-
-    return null;
-  }
-
-  transform(object: Node, parents: Node[]): void | ExitCallback {
-    return () => {
-      var classBody = object.body;
-      var className = object.id?.type === "Identifier" && object.id?.name;
-
-      if (!className) className = this.getPlaceholder();
-
-      var lexicalScope = getLexicalScope(object, parents);
-
-      var superMethodName: string;
-
-      for (var methodDefinition of classBody.body) {
-        if (
-          methodDefinition.type === "MethodDefinition" &&
-          methodDefinition.value.type === "FunctionExpression"
-        ) {
-          // Don't change constructors calling super()
-          if (methodDefinition.kind === "constructor" && object.superClass)
-            continue;
-
-          var functionExpression: Node = methodDefinition.value;
-
-          var fnName =
-            className +
-              "_" +
-              methodDefinition.kind +
-              "_" +
-              this.extractKeyString(methodDefinition) || this.getPlaceholder();
-
-          walk(
-            functionExpression,
-            [methodDefinition, object, ...parents],
-            (o, p) => {
-              if (o.type === "Super") {
-                var classContext = p.find((node) => isClass(node));
-                if (classContext !== object) return;
-
-                return () => {
-                  if (!superMethodName) {
-                    superMethodName =
-                      this.getGenerator("randomized").generate();
-                  }
-
-                  var memberExpression = p[0];
-                  if (memberExpression.type === "CallExpression") {
-                    throw new Error("Failed to detect super() usage");
-                  }
-                  ok(memberExpression.type === "MemberExpression");
-
-                  var propertyArg = memberExpression.computed
-                    ? memberExpression.property
-                    : (ok(memberExpression.property.type === "Identifier"),
-                      Literal(memberExpression.property.name));
-
-                  var getSuperExpression = CallExpression(
-                    MemberExpression(
-                      ThisExpression(),
-                      Literal(superMethodName),
-                      true
-                    ),
-                    [propertyArg]
-                  );
-
-                  if (p[1].type === "CallExpression" && p[1].callee === p[0]) {
-                    getSuperExpression = CallExpression(
-                      MemberExpression(
-                        getSuperExpression,
-                        Literal("bind"),
-                        true
-                      ),
-                      [ThisExpression()]
-                    );
-                  }
-
-                  this.replace(p[0], getSuperExpression);
-                };
-              }
-            }
-          );
-
-          var originalParams = functionExpression.params;
-          var originalBody = functionExpression.body.body;
-
-          functionExpression.body.body = [
-            ReturnStatement(
-              CallExpression(
-                MemberExpression(Identifier(fnName), Literal("apply"), true),
-                [ThisExpression(), Identifier("arguments")]
-              )
-            ),
-          ];
-
-          functionExpression.params = [];
-          if (methodDefinition.kind === "set") {
-            functionExpression.params = [Identifier(this.getPlaceholder())];
-          }
-
-          prepend(
-            lexicalScope,
-            FunctionDeclaration(fnName, [...originalParams], [...originalBody])
-          );
-        }
-      }
-
-      if (superMethodName) {
-        classBody.body.push(
-          MethodDefinition(
-            Literal(superMethodName),
-            FunctionExpression(
-              [Identifier("key")],
-              [
-                ReturnStatement(
-                  MemberExpression(Super(), Identifier("key"), true)
-                ),
-              ]
-            ),
-            "method",
-            false,
-            true
-          )
-        );
-      }
-    };
-  }
-}

package/src/transforms/identifier/globalAnalysis.ts

@@ -1,85 +0,0 @@
-import { reservedKeywords } from "../../constants";
-import { Location, Node } from "../../util/gen";
-import { getIdentifierInfo } from "../../util/identifiers";
-import Transform from "../transform";
-
-/**
- * Global Analysis is responsible for finding all the global variables used in the code.
- *
- * A 'global variable' is one that is:
- * - Referenced
- * - Never defined or overridden
- */
-export default class GlobalAnalysis extends Transform {
-  notGlobals: Set<string>;
-  globals: { [name: string]: Location[] };
-
-  constructor(o) {
-    super(o);
-
-    this.globals = Object.create(null);
-    this.notGlobals = new Set();
-  }
-
-  match(object: Node, parents: Node[]) {
-    return object.type == "Identifier" && !reservedKeywords.has(object.name);
-  }
-
-  transform(object: Node, parents: Node[]) {
-    // no touching `import()` or `import x from ...`
-    var importIndex = parents.findIndex(
-      (x) => x.type == "ImportExpression" || x.type == "ImportDeclaration"
-    );
-    if (importIndex !== -1) {
-      if (
-        parents[importIndex].source === (parents[importIndex - 1] || object)
-      ) {
-        return;
-      }
-    }
-
-    var info = getIdentifierInfo(object, parents);
-    if (!info.spec.isReferenced) {
-      return;
-    }
-
-    // Cannot be defined or overridden
-    if (info.spec.isDefined || info.spec.isModified) {
-      delete this.globals[object.name];
-
-      this.notGlobals.add(object.name);
-      return;
-    }
-
-    // Add to globals
-    if (!this.notGlobals.has(object.name)) {
-      if (!this.globals[object.name]) {
-        this.globals[object.name] = [];
-      }
-
-      this.globals[object.name].push([object, parents]);
-    }
-
-    var assignmentIndex = parents.findIndex(
-      (x) => x.type == "AssignmentExpression"
-    );
-    var updateIndex = parents.findIndex((x) => x.type == "UpdateExpression");
-
-    if (
-      (assignmentIndex != -1 &&
-        parents[assignmentIndex].left ===
-          (parents[assignmentIndex - 1] || object)) ||
-      updateIndex != -1
-    ) {
-      var memberIndex = parents.findIndex((x) => x.type == "MemberExpression");
-      if (
-        memberIndex == -1 ||
-        memberIndex > (assignmentIndex == -1 ? assignmentIndex : updateIndex)
-      ) {
-        delete this.globals[object.name];
-
-        this.notGlobals.add(object.name);
-      }
-    }
-  }
-}

package/src/transforms/identifier/variableAnalysis.ts

@@ -1,118 +0,0 @@
-import { ok } from "assert";
-import { reservedIdentifiers } from "../../constants";
-import { isValidIdentifier } from "../../util/compare";
-import { Node } from "../../util/gen";
-import { getIdentifierInfo } from "../../util/identifiers";
-import {
-  getReferencingContexts,
-  getAllDefiningContexts,
-} from "../../util/insert";
-import Transform from "../transform";
-
-/**
- * Keeps track of what identifiers are defined and referenced in each context.
- */
-export default class VariableAnalysis extends Transform {
-  /**
-   * Node being the context.
-   */
-  defined: Map<Node, Set<string>>;
-
-  /**
-   * Context->Nodes referenced (does not include nested)
-   */
-  references: Map<Node, Set<string>>;
-
-  /**
-   * Set of global identifiers to never be redefined
-   *
-   * - Used to not accidentally block access to a global variable
-   */
-  globals: Set<string>;
-
-  /**
-   * Set of identifiers that are defined within the program
-   */
-  notGlobals: Set<string>;
-
-  constructor(o) {
-    super(o);
-
-    this.defined = new Map();
-    this.references = new Map();
-    this.globals = new Set();
-    this.notGlobals = new Set();
-  }
-
-  match(object, parents) {
-    return object.type === "Identifier";
-  }
-
-  transform(object: Node, parents: Node[]) {
-    var name = object.name;
-    ok(typeof name === "string");
-    if (!isValidIdentifier(name)) {
-      return;
-    }
-
-    if (reservedIdentifiers.has(name)) {
-      return;
-    }
-    if (this.options.globalVariables.has(name)) {
-      return;
-    }
-
-    var info = getIdentifierInfo(object, parents);
-    if (!info.spec.isReferenced) {
-      return;
-    }
-
-    if (info.spec.isExported) {
-      return;
-    }
-
-    var isDefined = info.spec.isDefined;
-
-    // Keep track of defined names within the program
-    if (isDefined) {
-      this.notGlobals.add(object.name);
-      this.globals.delete(object.name);
-    } else if (!this.notGlobals.has(object.name)) {
-      this.globals.add(object.name);
-    }
-
-    var definingContexts = info.spec.isDefined
-      ? getAllDefiningContexts(object, parents)
-      : getReferencingContexts(object, parents, info);
-
-    ok(definingContexts.length);
-
-    definingContexts.forEach((definingContext) => {
-      // ok(
-      //   isContext(definingContext),
-      //   `${definingContext.type} is not a context`
-      // );
-
-      if (isDefined) {
-        // Add to defined Map
-        if (!this.defined.has(definingContext)) {
-          this.defined.set(definingContext, new Set());
-        }
-        this.defined.get(definingContext).add(name);
-        this.references.has(definingContext) &&
-          this.references.get(definingContext).delete(name);
-      } else {
-        // Add to references Map
-        if (
-          !this.defined.has(definingContext) ||
-          !this.defined.get(definingContext).has(name)
-        ) {
-          if (!this.references.has(definingContext)) {
-            this.references.set(definingContext, new Set());
-          }
-          this.references.get(definingContext).add(name);
-        }
-      }
-    });
-  }
-}

package/src/transforms/lock/antiDebug.ts

@@ -1,112 +0,0 @@
-import { ObfuscateOrder } from "../../order";
-import Template from "../../templates/template";
-import { isBlock } from "../../traverse";
-import {
-  AssignmentExpression,
-  DebuggerStatement,
-  ExpressionStatement,
-  FunctionDeclaration,
-  Identifier,
-  IfStatement,
-  Literal,
-  WhileStatement,
-} from "../../util/gen";
-import { getBlockBody, prepend } from "../../util/insert";
-import { getRandomInteger } from "../../util/random";
-import Transform from "../transform";
-import Lock from "./lock";
-
-var DevToolsDetection = Template(
-  `
-  try {
-    if ( setInterval ) {
-      setInterval(()=>{
-        {functionName}();
-      }, 4000);
-    }
-  } catch ( e ) {
-
-  }
-`
-);
-
-export default class AntiDebug extends Transform {
-  made: number;
-  lock: Lock;
-
-  constructor(o, lock) {
-    super(o, ObfuscateOrder.Lock);
-
-    this.lock = lock;
-    this.made = 0;
-  }
-
-  apply(tree) {
-    super.apply(tree);
-
-    var fnName = this.getPlaceholder();
-    var startTimeName = this.getPlaceholder();
-    var endTimeName = this.getPlaceholder();
-    var isDevName = this.getPlaceholder();
-    var functionDeclaration = FunctionDeclaration(
-      fnName,
-      [],
-      [
-        ...Template(`
-      var ${startTimeName} = new Date();
-      debugger;
-      var ${endTimeName} = new Date();
-      var ${isDevName} = ${endTimeName}-${startTimeName} > 1000;
-      `).compile(),
-
-        IfStatement(
-          Identifier(isDevName),
-          this.options.lock.countermeasures
-            ? this.lock.getCounterMeasuresCode(tree.body, [tree])
-            : [
-                WhileStatement(Identifier(isDevName), [
-                  ExpressionStatement(
-                    AssignmentExpression(
-                      "=",
-                      Identifier(startTimeName),
-                      Identifier(endTimeName)
-                    )
-                  ),
-                ]),
-              ],
-          null
-        ),
-      ]
-    );
-
-    tree.body.unshift(...DevToolsDetection.compile({ functionName: fnName }));
-    tree.body.push(functionDeclaration);
-  }
-
-  match(object, parents) {
-    return isBlock(object);
-  }
-
-  transform(object, parents) {
-    return () => {
-      var body = getBlockBody(object.body);
-
-      [...body].forEach((stmt, i) => {
-        var addDebugger = Math.random() < 0.1 / (this.made || 1);
-
-        if (object.type == "Program" && i == 0) {
-          addDebugger = true;
-        }
-
-        if (addDebugger) {
-          var index = getRandomInteger(0, body.length);
-          if (body[index].type != "DebuggerStatement") {
-            body.splice(index, 0, DebuggerStatement());
-
-            this.made++;
-          }
-        }
-      });
-    };
-  }
-}