js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/constants.ts

@@ -1,72 +1,86 @@
+import ControlObject from "./utils/ControlObject";
+
+export const predictableFunctionTag = "__JS_PREDICT__";
+
 /**
- * Keywords disallowed for variable names in ES5 and under.
+ * A function is 'unsafe' if it requires 'eval', 'arguments' or 'this'
+ *
+ * Transformations will generally not touch unsafe functions.
  */
-export const reservedKeywords = new Set([
-  "abstract",
-  "arguments",
-  "await",
-  "boolean",
-  "break",
-  "byte",
-  "case",
-  "catch",
-  "char",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "double",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "final",
-  "finally",
-  "float",
-  "for",
-  "function",
-  "goto",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "int",
-  "interface",
-  "let",
-  "long",
-  "native",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "short",
-  "static",
-  "super",
-  "switch",
-  "synchronized",
-  "this",
-  "throw",
-  "throws",
-  "transient",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "volatile",
-  "while",
-  "with",
-  "yield",
-]);
+export const UNSAFE = Symbol("unsafe");
+
+/**
+ * A function is 'predictable' if the invoking parameter lengths are guaranteed to be known.
+ *
+ * ```js
+ * a(1,2,3) // predictable
+ * a(...[1,2,3]) // unpredictable
+ * ```
+ */
+export const PREDICTABLE = Symbol("predictable");
+
+/**
+ * A node is marked as 'skip' if it should not be transformed.
+ *
+ * Preserved throughout transformations, so be careful with this.
+ */
+export const SKIP = Symbol("skip");
+
+/**
+ * Saves the original length of a function.
+ */
+export const FN_LENGTH = Symbol("fnLength");
+
+export const CONTROL_OBJECTS = Symbol("controlObjects");
+
+export const NO_RENAME = Symbol("noRename");
+
+/**
+ * This Identifier is used for a hexadecimal number or escaped string.
+ */
+export const GEN_NODE = Symbol("genNode");
+
+/**
+ * This function is used to mark functions that when transformed will most likely cause a maximum call stack error.
+ *
+ * Examples: Native Function Check
+ */
+export const MULTI_TRANSFORM = Symbol("multiTransform");
+
+/**
+ * The function contains a `with` statement.
+ *
+ * OR
+ *
+ * This identifier is used for a `with` statement.
+ *
+ * Tells Pack not to globally transform the node.
+ */
+export const WITH_STATEMENT = Symbol("withStatement");
+
+/**
+ * Symbols describe precomputed semantics of a node, allowing the obfuscator to make the best choices for the node.
+ */
+export interface NodeSymbol {
+  [UNSAFE]?: boolean;
+  [PREDICTABLE]?: boolean;
+  [SKIP]?: boolean | number;
+  [FN_LENGTH]?: number;
+  [CONTROL_OBJECTS]?: ControlObject[];
+  [NO_RENAME]?: string | number;
+
+  [GEN_NODE]?: boolean;
+  [MULTI_TRANSFORM]?: boolean;
+  [WITH_STATEMENT]?: boolean;
+}
+
+/**
+ * Allows the user to grab the variable name of a renamed variable.
+ */
+export const variableFunctionName = "__JS_CONFUSER_VAR__";
+
+export const noRenameVariablePrefix = "__NO_JS_CONFUSER_RENAME__";
+export const placeholderVariablePrefix = "__p_";
 
 /**
  * Identifiers that are not actually variables.
@@ -80,17 +94,65 @@ export const reservedIdentifiers = new Set([
   "arguments",
 ]);
 
-export const noRenameVariablePrefix = "__NO_JS_CONFUSER_RENAME__";
-export const placeholderVariablePrefix = "__p_";
+export const reservedObjectPrototype = new Set([
+  "toString",
+  "valueOf",
+  "constructor",
+  "__proto__",
+  "hasOwnProperty",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "toLocaleString",
+]);
 
 /**
- * Tells the obfuscator this function is predictable:
- * -  Never called with extraneous parameters
+ * For Zero Width generator - Mangled variable names
  */
-export const predictableFunctionTag = "__JS_PREDICT__";
+export const reservedKeywords = [
+  "if",
+  "in",
+  "for",
+  "let",
+  "new",
+  "try",
+  "var",
+  "case",
+  "else",
+  "null",
+  "break",
+  "catch",
+  "class",
+  "const",
+  "super",
+  "throw",
+  "while",
+  "yield",
+  "delete",
+  "export",
+  "import",
+  "public",
+  "return",
+  "switch",
+  "default",
+  "finally",
+  "private",
+  "continue",
+  "debugger",
+  "function",
+  "arguments",
+  "protected",
+  "instanceof",
+  "await",
+  "async",
 
-/**
- * Tells the obfuscator this function is critical for the Obfuscated code.
- * -  Example: string decryption function
- */
-export const criticalFunctionTag = "__JS_CRITICAL__";
+  // new key words and other fun stuff :P
+  "NaN",
+  "undefined",
+  "true",
+  "false",
+  "typeof",
+  "this",
+  "static",
+  "void",
+  "of",
+];

package/src/index.ts

@@ -1,196 +1,103 @@
-import compileJs, { compileJsSync } from "./compiler";
-import parseJS, { parseSync } from "./parser";
+import * as babelTypes from "@babel/types";
 import Obfuscator from "./obfuscator";
-import Transform from "./transforms/transform";
-import { remove$Properties } from "./util/object";
-import presets from "./presets";
-
-import * as assert from "assert";
-import { correctOptions, ObfuscateOptions, validateOptions } from "./options";
+import { ObfuscateOptions } from "./options";
 import {
-  IJsConfuser,
-  IJsConfuserDebugObfuscation,
-  IJsConfuserDebugTransformations,
-} from "./types";
-
-/**
- * **JsConfuser**: Obfuscates JavaScript.
- * @param code - The code to be obfuscated.
- * @param options - An object of obfuscation options: `{preset: "medium", target: "browser"}`.
- */
-export async function obfuscate(code: string, options: ObfuscateOptions) {
-  return await JsConfuser(code, options);
-}
-
-/**
- * Obfuscates an [ESTree](https://github.com/estree/estree) compliant AST.
- *
- * **Note:** Mutates the object.
- *
- * @param AST - The [ESTree](https://github.com/estree/estree) compliant AST. This object will be mutated.
- * @param options - The obfuscation options.
- *
- * [See all settings here](https://github.com/MichaelXF/js-confuser#options)
- */
-export async function obfuscateAST(AST, options: ObfuscateOptions) {
-  assert.ok(typeof AST === "object", "AST must be type object");
-  assert.ok(AST.type == "Program", "AST.type must be equal to 'Program'");
-  validateOptions(options);
-
-  options = await correctOptions(options);
-
-  var obfuscator = new Obfuscator(options);
-
-  await obfuscator.apply(AST);
+  ObfuscationResult,
+  ProfileData,
+  ProfilerCallback,
+  ProfilerLog,
+} from "./obfuscationResult";
+import presets from "./presets";
+import Template from "./templates/template";
 
-  options.verbose && console.log("* Removing $ properties");
+export async function obfuscate(
+  sourceCode: string,
+  options: ObfuscateOptions
+): Promise<ObfuscationResult> {
+  const obfuscator = new Obfuscator(options);
 
-  remove$Properties(AST);
+  return obfuscator.obfuscate(sourceCode);
 }
 
-/**
- * **JsConfuser**: Obfuscates JavaScript.
- * @param code - The code to be obfuscated.
- * @param options - An object of obfuscation options: `{preset: "medium", target: "browser"}`.
- */
-var JsConfuser: IJsConfuser = async function (
-  code: string,
+export async function obfuscateAST(
+  ast: babelTypes.File,
   options: ObfuscateOptions
-): Promise<string> {
-  if (typeof code !== "string") {
-    throw new TypeError("code must be type string");
-  }
-  validateOptions(options);
-
-  options = await correctOptions(options);
-
-  options.verbose && console.log("* Parsing source code");
-
-  var tree = await parseJS(code);
-
-  options.verbose && console.log("* Obfuscating...");
-
-  var obfuscator = new Obfuscator(options);
-
-  await obfuscator.apply(tree);
-
-  options.verbose && console.log("* Removing $ properties");
-
-  remove$Properties(tree);
-
-  options.verbose && console.log("* Generating code");
-
-  var result = await compileJs(tree, options);
-
-  return result;
-} as any;
-
-export const debugTransformations: IJsConfuserDebugTransformations =
-  async function (
-    code: string,
-    options: ObfuscateOptions
-  ): Promise<{ name: string; code: string; ms: number }[]> {
-    validateOptions(options);
-    options = await correctOptions(options);
-
-    var frames = [];
-
-    var tree = parseSync(code);
-    var obfuscator = new Obfuscator(options);
-
-    var time = Date.now();
-
-    obfuscator.on("debug", (name: string, tree: Node) => {
-      frames.push({
-        name: name,
-        code: compileJsSync(tree, options),
-        ms: Date.now() - time,
-      });
-
-      time = Date.now();
-    });
-
-    await obfuscator.apply(tree, true);
+) {
+  const obfuscator = new Obfuscator(options);
 
-    return frames;
-  };
+  return obfuscator.obfuscateAST(ast);
+}
 
-/**
- * This method is used by the obfuscator website to display a progress bar and additional information
- * about the obfuscation.
- *
- * @param code - Source code to obfuscate
- * @param options - Options
- * @param callback - Progress callback, called after each transformation
- * @returns
- */
-export const debugObfuscation: IJsConfuserDebugObfuscation = async function (
-  code: string,
+export async function obfuscateWithProfiler(
+  sourceCode: string,
   options: ObfuscateOptions,
-  callback: (name: string, complete: number, totalTransforms: number) => void,
-  performance: Performance
-) {
+  profiler: {
+    callback: ProfilerCallback;
+    performance: { now(): number };
+  }
+): Promise<ObfuscationResult & { profileData: ProfileData }> {
   const startTime = performance.now();
 
-  validateOptions(options);
-  options = await correctOptions(options);
+  const obfuscator = new Obfuscator(options);
+  let totalTransforms = obfuscator.plugins.length;
+
+  let transformMap: ProfileData["transforms"] = Object.create(null);
 
   const beforeParseTime = performance.now();
 
-  var tree = parseSync(code);
+  let ast = Obfuscator.parseCode(sourceCode);
 
   const parseTime = performance.now() - beforeParseTime;
 
-  var obfuscator = new Obfuscator(options);
-  var totalTransforms = obfuscator.array.length;
-
-  var transformationTimes = Object.create(null);
-  var currentTransformTime = performance.now();
-
-  obfuscator.on("debug", (name: string, tree: Node, i: number) => {
-    var nowTime = performance.now();
-    transformationTimes[name] = nowTime - currentTransformTime;
-    currentTransformTime = nowTime;
-
-    callback(name, i, totalTransforms);
+  let currentTransformTime = performance.now();
+
+  ast = obfuscator.obfuscateAST(ast, {
+    profiler: (log: ProfilerLog) => {
+      var nowTime = performance.now();
+      transformMap[log.currentTransform] = {
+        transformTime: nowTime - currentTransformTime,
+        changeData: {},
+      };
+      currentTransformTime = nowTime;
+      profiler.callback(log);
+    },
   });
 
-  await obfuscator.apply(tree, true);
+  obfuscator.plugins.forEach(({ pluginInstance }) => {
+    if (transformMap[pluginInstance.name]) {
+      transformMap[pluginInstance.name].changeData = pluginInstance.changeData;
+    }
+  });
 
   const beforeCompileTime = performance.now();
 
-  var output = await compileJs(tree, options);
+  const code = Obfuscator.generateCode(ast, obfuscator.options);
 
   const compileTime = performance.now() - beforeCompileTime;
 
   const endTime = performance.now();
 
+  const obfuscationTime = endTime - startTime;
+
   return {
-    obfuscated: output,
-    transformationTimes: transformationTimes,
-    obfuscationTime: endTime - startTime,
-    parseTime: parseTime,
-    compileTime: compileTime,
-    totalTransforms: totalTransforms,
-    totalPossibleTransforms: obfuscator.totalPossibleTransforms,
+    code: code,
+    profileData: {
+      transforms: transformMap,
+      obfuscationTime: obfuscationTime,
+      parseTime: parseTime,
+      compileTime: compileTime,
+      totalTransforms: totalTransforms,
+      totalPossibleTransforms: obfuscator.totalPossibleTransforms,
+    },
   };
-};
-
-JsConfuser.obfuscate = obfuscate;
-JsConfuser.obfuscateAST = obfuscateAST;
-JsConfuser.presets = presets;
-JsConfuser.debugTransformations = debugTransformations;
-JsConfuser.debugObfuscation = debugObfuscation;
-JsConfuser.Obfuscator = Obfuscator;
-JsConfuser.Transform = Transform;
-
-if (typeof window !== "undefined") {
-  window["JsConfuser"] = JsConfuser;
-}
-if (typeof global !== "undefined") {
-  global["JsConfuser"] = JsConfuser;
 }
 
-export default JsConfuser;
+const JsConfuser = {
+  obfuscate,
+  obfuscateAST,
+  obfuscateWithProfiler,
+  presets,
+  Template,
+};
 
-export { presets, Obfuscator, Transform };
+export default JsConfuser;

package/src/obfuscationResult.ts

@@ -0,0 +1,43 @@
+import { PluginInstance } from "./transforms/plugin";
+
+/**
+ * Obfuscation result object.
+ */
+export interface ObfuscationResult {
+  /**
+   * Obfuscated code.
+   */
+  code: string;
+}
+
+/**
+ * Profile report for the obfuscation process.
+ */
+export interface ProfileData {
+  obfuscationTime: number;
+  compileTime: number;
+  parseTime: number;
+  totalPossibleTransforms: number;
+  totalTransforms: number;
+  transforms: {
+    [transformName: string]: {
+      transformTime: number;
+      changeData: PluginInstance["changeData"];
+    };
+  };
+}
+
+/**
+ * A callback function that is called when a transform is applied.
+ */
+export type ProfilerCallback = (log: ProfilerLog) => void;
+
+/**
+ * The current progress of the obfuscation process.
+ */
+export interface ProfilerLog {
+  index: number;
+  currentTransform: string;
+  nextTransform: string;
+  totalTransforms: number;
+}