js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/transforms/controlFlowFlattening/expressionObfuscation.ts

@@ -1,179 +0,0 @@
-import { criticalFunctionTag } from "../../constants";
-import Template from "../../templates/template";
-import { isBlock } from "../../traverse";
-import {
-  CallExpression,
-  Identifier,
-  Node,
-  SequenceExpression,
-} from "../../util/gen";
-import { prepend } from "../../util/insert";
-import Transform from "../transform";
-
-/**
- * Expression Obfuscation runs before Control Flow Flattening
- */
-export default class ExpressionObfuscation extends Transform {
-  fnName: string;
-
-  constructor(o) {
-    super(o);
-  }
-
-  apply(tree: Node): void {
-    super.apply(tree);
-
-    if (typeof this.fnName === "string") {
-      prepend(
-        tree,
-        Template(`
-        function {fnName}(...args){
-          return args[args["length"] - 1]
-        }
-        `).single({ fnName: this.fnName })
-      );
-    }
-  }
-
-  createSequenceExpression(expressions: Node[]): Node {
-    if (!this.fnName) {
-      this.fnName = this.getPlaceholder() + criticalFunctionTag;
-    }
-
-    return CallExpression(Identifier(this.fnName), [...expressions]);
-  }
-
-  match(object, parents) {
-    return isBlock(object);
-  }
-
-  transform(object, parents) {
-    return () => {
-      var exprs = [];
-      var deleteExprs = [];
-
-      object.body.forEach((stmt, i) => {
-        if (stmt.type == "ExpressionStatement" && !stmt.directive) {
-          var expr = stmt.expression;
-
-          if (
-            expr.type == "UnaryExpression" &&
-            !(
-              expr.operator === "typeof" && expr.argument.type === "Identifier"
-            ) &&
-            exprs.length // typeof is special
-          ) {
-            expr.argument = SequenceExpression([
-              ...exprs,
-              { ...expr.argument },
-            ]);
-            deleteExprs.push(...exprs);
-
-            exprs = [];
-          } else {
-            exprs.push(expr);
-          }
-        } else {
-          if (exprs.length) {
-            if (stmt.type == "IfStatement") {
-              if (
-                stmt.test.type == "BinaryExpression" &&
-                stmt.test.operator !== "**"
-              ) {
-                if (
-                  stmt.test.left.type == "UnaryExpression" &&
-                  !(
-                    stmt.test.left.operator === "typeof" &&
-                    stmt.test.left.argument.type === "Identifier"
-                  ) // typeof is special
-                ) {
-                  stmt.test.left.argument = this.createSequenceExpression([
-                    ...exprs,
-                    { ...stmt.test.left.argument },
-                  ]);
-                } else {
-                  stmt.test.left = this.createSequenceExpression([
-                    ...exprs,
-                    { ...stmt.test.left },
-                  ]);
-                }
-              } else if (
-                stmt.test.type == "LogicalExpression" &&
-                stmt.test.left.type == "BinaryExpression" &&
-                stmt.test.operator !== "**" &&
-                stmt.test.left.left.type == "UnaryExpression"
-              ) {
-                stmt.test.left.left.argument = this.createSequenceExpression([
-                  ...exprs,
-                  { ...stmt.test.left.left.argument },
-                ]);
-              } else {
-                stmt.test = this.createSequenceExpression([
-                  ...exprs,
-                  { ...stmt.test },
-                ]);
-              }
-              deleteExprs.push(...exprs);
-            } else if (
-              stmt.type == "ForStatement" ||
-              (stmt.type == "LabeledStatement" &&
-                stmt.body.type == "ForStatement")
-            ) {
-              var init = (stmt.type == "LabeledStatement" ? stmt.body : stmt)
-                .init;
-
-              if (init) {
-                if (init.type == "VariableDeclaration") {
-                  init.declarations[0].init = this.createSequenceExpression([
-                    ...exprs,
-                    {
-                      ...(init.declarations[0].init || Identifier("undefined")),
-                    },
-                  ]);
-                  deleteExprs.push(...exprs);
-                } else if (init.type == "AssignmentExpression") {
-                  init.right = this.createSequenceExpression([
-                    ...exprs,
-                    {
-                      ...(init.right || Identifier("undefined")),
-                    },
-                  ]);
-                  deleteExprs.push(...exprs);
-                }
-              }
-            } else if (stmt.type == "VariableDeclaration") {
-              stmt.declarations[0].init = this.createSequenceExpression([
-                ...exprs,
-                {
-                  ...(stmt.declarations[0].init || Identifier("undefined")),
-                },
-              ]);
-              deleteExprs.push(...exprs);
-            } else if (stmt.type == "ThrowStatement") {
-              stmt.argument = this.createSequenceExpression([
-                ...exprs,
-                { ...stmt.argument },
-              ]);
-              deleteExprs.push(...exprs);
-            } else if (stmt.type == "ReturnStatement") {
-              stmt.argument = this.createSequenceExpression([
-                ...exprs,
-                { ...(stmt.argument || Identifier("undefined")) },
-              ]);
-              deleteExprs.push(...exprs);
-            }
-          }
-
-          exprs = [];
-        }
-      });
-
-      deleteExprs.forEach((expr) => {
-        var index = object.body.findIndex((x) => x.expression === expr);
-        if (index !== -1) {
-          object.body.splice(index, 1);
-        }
-      });
-    };
-  }
-}

package/src/transforms/es5/antiClass.ts

@@ -1,272 +0,0 @@
-import Transform from "../transform";
-import Template from "../../templates/template";
-import { walk } from "../../traverse";
-import {
-  AssignmentExpression,
-  CallExpression,
-  ExpressionStatement,
-  FunctionExpression,
-  Identifier,
-  MemberExpression,
-  Node,
-  ReturnStatement,
-  SpreadElement,
-  ThisExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import { ok } from "assert";
-
-export default class AntiClass extends Transform {
-  constructor(o) {
-    super(o);
-  }
-
-  match(o, p) {
-    return o.type == "ClassDeclaration" || o.type == "ClassExpression";
-  }
-
-  transform(object, parents) {
-    return () => {
-      var body = object.body;
-      if (body.type !== "ClassBody") {
-        return;
-      }
-      if (!Array.isArray(body.body)) {
-        return;
-      }
-
-      var isDeclaration = object.type == "ClassDeclaration";
-
-      var virtualName = "virtual" + this.getPlaceholder();
-
-      var staticBody: Node[] = [];
-      var virtualBody: Node[] = [];
-      var superName;
-      var thisName = "this" + this.getPlaceholder();
-
-      // self this
-      virtualBody.push(Template(`var ${thisName} = this;`).single());
-      virtualBody.push(Template(`${thisName}["constructor"] = null;`).single());
-      var superArguments;
-      var superBody = [];
-
-      if (object.superClass) {
-        superName = "super" + this.getPlaceholder();
-      }
-
-      var virtualDescriptorsName = this.getPlaceholder();
-      var staticDescriptorsName = this.getPlaceholder();
-
-      // getters/setters
-      virtualBody.push(
-        Template(
-          `var ${virtualDescriptorsName} = {getters: {}, setters: {}}`
-        ).single()
-      );
-
-      // getters/setters
-      staticBody.push(
-        Template(
-          `var ${staticDescriptorsName} = {getters: {}, setters: {}}`
-        ).single()
-      );
-
-      body.body.forEach((methodDefinition) => {
-        if (!methodDefinition.key) {
-          return;
-        }
-        var isStatic = methodDefinition.static;
-
-        var key = MemberExpression(
-          isStatic ? Identifier(virtualName) : ThisExpression(),
-          methodDefinition.key,
-          methodDefinition.computed
-        );
-        var value = methodDefinition.value;
-
-        var pushingTo = isStatic ? staticBody : virtualBody;
-
-        if (superName && value.type == "FunctionExpression") {
-          var first = value.body.body[0];
-          if (
-            first.type == "ExpressionStatement" &&
-            first.expression.type == "CallExpression"
-          ) {
-            if (first.expression.callee.type == "Super") {
-              /// super(...args)
-              superArguments = first.expression.arguments;
-              value.body.body.shift();
-            } else if (
-              // F(super(...args))
-              first.expression.arguments[0] &&
-              first.expression.arguments[0].type === "CallExpression" &&
-              first.expression.arguments[0].callee.type === "Super"
-            ) {
-              superArguments = first.expression.arguments[0].arguments;
-              first.expression.arguments[0] = Identifier("undefined");
-            }
-          }
-
-          walk(
-            value.body,
-            [value, methodDefinition, body.body, body, object, ...parents],
-            (o, p) => {
-              if (o.type == "Super") {
-                this.replace(o, Identifier(superName));
-              }
-            }
-          );
-        }
-
-        // Support class fields
-        if (methodDefinition.type === "PropertyDefinition") {
-          var assignmentExpression = AssignmentExpression(
-            "=",
-            key,
-            value || Identifier("undefined")
-          );
-
-          pushingTo.push(ExpressionStatement(assignmentExpression));
-        } else if (
-          methodDefinition.kind == "constructor" ||
-          methodDefinition.kind == "method"
-        ) {
-          pushingTo.push(
-            ExpressionStatement(AssignmentExpression("=", key, value))
-          );
-        } else if (
-          methodDefinition.kind == "get" ||
-          methodDefinition.kind == "set"
-        ) {
-          var id = Identifier(
-            methodDefinition.kind == "get" ? "getters" : "setters"
-          );
-          var type = MemberExpression(
-            Identifier(
-              isStatic ? staticDescriptorsName : virtualDescriptorsName
-            ),
-            id,
-            false
-          );
-
-          var assignmentExpression = AssignmentExpression(
-            "=",
-
-            MemberExpression(
-              type,
-              methodDefinition.key,
-              methodDefinition.computed
-            ),
-            value
-          );
-
-          pushingTo.push(ExpressionStatement(assignmentExpression));
-        } else {
-          console.log(methodDefinition);
-          throw new Error("Unsupported method definition");
-        }
-      });
-
-      virtualBody.push(
-        Template(`
-      [...Object.keys(${virtualDescriptorsName}.getters), ...Object.keys(${virtualDescriptorsName}.setters)].forEach(key=>{
-  
-        if( !${thisName}.hasOwnProperty(key) ) {
-          var getter = ${virtualDescriptorsName}.getters[key];
-          var setter = ${virtualDescriptorsName}.setters[key];
-          Object.defineProperty(${thisName}, key, {
-            get: getter,
-            set: setter,
-            configurable: true
-          })
-        }
-  
-      })
-      
-      `).single()
-      );
-
-      staticBody.push(
-        Template(`
-      [...Object.keys(${staticDescriptorsName}.getters), ...Object.keys(${staticDescriptorsName}.setters)].forEach(key=>{
-  
-        if( !${virtualName}.hasOwnProperty(key) ) {
-          var getter = ${staticDescriptorsName}.getters[key];
-          var setter = ${staticDescriptorsName}.setters[key];
-          Object.defineProperty(${virtualName}, key, {
-            get: getter,
-            set: setter,
-            configurable: true
-          })
-        }
-  
-      })
-      
-      `).single()
-      );
-
-      if (superName) {
-        ok(superArguments, "Failed to find super() arguments");
-
-        // save the super state
-        virtualBody.unshift(
-          Template(
-            `
-            Object.keys(this).forEach(key=>{
-              var descriptor = Object.getOwnPropertyDescriptor(this, key);
-              if ( descriptor) {
-                Object.defineProperty(${superName}, key, descriptor)
-              } else {
-                ${superName}[key] = this[key];
-              }
-            })`
-          ).single()
-        );
-
-        virtualBody.unshift(
-          ExpressionStatement(
-            CallExpression(
-              MemberExpression(object.superClass, Identifier("call"), false),
-              [ThisExpression(), ...superArguments]
-            )
-          )
-        );
-
-        virtualBody.unshift(Template(`var ${superName} = {}`).single());
-      }
-
-      virtualBody.push(
-        Template(
-          `if(!this["constructor"]){this["constructor"] = ()=>{}};`
-        ).single()
-      );
-      if (object.id && object.id.name) {
-        virtualBody.push(
-          Template(`Object.defineProperty(this["constructor"], 'name', {
-          writable: true,
-          configurable: true,
-          value: '${object.id.name}'
-        });`).single()
-        );
-      }
-
-      virtualBody.push(Template(`this["constructor"](...arguments)`).single());
-
-      var virtualFunction = FunctionExpression([], virtualBody);
-
-      var completeBody = [
-        VariableDeclaration(VariableDeclarator(virtualName, virtualFunction)),
-        ...staticBody,
-        ReturnStatement(Identifier(virtualName)),
-      ];
-
-      var expr: Node = CallExpression(FunctionExpression([], completeBody), []);
-      if (isDeclaration) {
-        expr = VariableDeclaration(VariableDeclarator(object.id, expr));
-      }
-
-      this.replace(object, expr);
-    };
-  }
-}