js-confuser 1.7.2 → 2.0.0-alpha.0

package/src/transforms/string/stringCompression.ts

@@ -1,237 +1,119 @@
-import { ok } from "assert";
-import { ObfuscateOrder } from "../../order";
-import { ComputeProbabilityMap } from "../../probability";
-import Template from "../../templates/template";
-import { isDirective, isModuleSource } from "../../util/compare";
+import { PluginArg, PluginObject } from "../plugin";
+import * as t from "@babel/types";
+import { Order } from "../../order";
+import { computeProbabilityMap } from "../../probability";
 import {
-  CallExpression,
-  FunctionDeclaration,
-  FunctionExpression,
-  Identifier,
-  Literal,
-  MemberExpression,
-  ReturnStatement,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../../util/gen";
-import { append, prepend } from "../../util/insert";
-import Transform from "../transform";
-import { predictableFunctionTag } from "../../constants";
-
-function LZ_encode(c) {
-  ok(c);
-  var x = "charCodeAt",
-    b,
-    e = {},
-    f = c.split(""),
-    d = [],
-    a = f[0],
-    g = 256;
-  for (b = 1; b < f.length; b++)
-    (c = f[b]),
-      null != e[a + c]
-        ? (a += c)
-        : (d.push(1 < a.length ? e[a] : a[x](0)), (e[a + c] = g), g++, (a = c));
-  d.push(1 < a.length ? e[a] : a[x](0));
-  for (b = 0; b < d.length; b++) d[b] = String.fromCharCode(d[b]);
-  return d.join("");
-}
-
-function LZ_decode(b) {
-  ok(b);
-  var o,
-    f,
-    a,
-    e = {},
-    d = b.split(""),
-    c = (f = d[0]),
-    g = [c],
-    h = (o = 256);
-  for (var i = 1; i < d.length; i++)
-    (a = d[i].charCodeAt(0)),
-      (a = h > a ? d[i] : e[a] ? e[a] : f + c),
-      g.push(a),
-      (c = a.charAt(0)),
-      (e[o] = f + c),
-      o++,
-      (f = a);
-  return g.join("");
-}
-
-const DecodeTemplate = Template(
-  `function {name}(b){
-    var o,
-    f,
-    a,
-    e = {},
-    d = b.split(""),
-    c = (f = d[0]),
-    g = [c],
-    h = (o = 256);
-  for (b = 1; b < d.length; b++)
-    (a = d[b].charCodeAt(0)),
-      (a = h > a ? d[b] : e[a] ? e[a] : f + c),
-      g.push(a),
-      (c = a.charAt(0)),
-      (e[o] = f + c),
-      o++,
-      (f = a);
-  return g.join("").split("{delimiter}");
-  }`
-);
-
-export default class StringCompression extends Transform {
-  map: Map<string, number>;
-  ignore: Set<string>;
-  string: string;
-  delimiter = "|";
-
-  fnName: string;
-
-  constructor(o) {
-    super(o, ObfuscateOrder.StringCompression);
-
-    this.map = new Map();
-    this.ignore = new Set();
-    this.string = "";
-    this.fnName = this.getPlaceholder() + predictableFunctionTag;
-  }
-
-  apply(tree) {
-    super.apply(tree);
-
-    this.string = this.string.slice(0, this.string.length - 1);
-    if (!this.string.length) {
-      return;
-    }
-
-    var split = this.getPlaceholder();
-    var decoder = this.getPlaceholder();
-    var getStringName = this.getPlaceholder() + predictableFunctionTag; // Returns the string payload
-
-    var encoded = LZ_encode(this.string);
-    if (LZ_decode(encoded) !== this.string) {
-      this.error(
-        new Error(
-          "String failed to be decoded. Try disabling the 'stringCompression' option."
-        )
-      );
-    }
-
-    var getStringParamName = this.getPlaceholder();
-    var decoderParamName = this.getPlaceholder();
-
-    var callExpression = CallExpression(Identifier(decoderParamName), [
-      CallExpression(Identifier(getStringParamName), []),
-    ]);
-
-    prepend(
-      tree,
-      VariableDeclaration(
-        VariableDeclarator(
-          split,
-          CallExpression(
-            FunctionExpression(
-              [Identifier(getStringParamName), Identifier(decoderParamName)],
-              [ReturnStatement(callExpression)]
-            ),
-            [Identifier(getStringName), Identifier(decoder)]
-          )
-        )
-      )
-    );
-
-    append(
-      tree,
-      FunctionDeclaration(
-        getStringName,
-        [],
-        [ReturnStatement(Literal(encoded))]
-      )
-    );
-
-    append(
-      tree,
-      FunctionDeclaration(
-        this.fnName,
-        [Identifier("index")],
-        [
-          ReturnStatement(
-            MemberExpression(Identifier(split), Identifier("index"), true)
-          ),
-        ]
-      )
-    );
-
-    append(
-      tree,
-      DecodeTemplate.single({ name: decoder, delimiter: this.delimiter })
-    );
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "Literal" &&
-      typeof object.value === "string" &&
-      object.value &&
-      object.value.length > 3 &&
-      !isDirective(object, parents) &&
-      !isModuleSource(object, parents)
-    );
-  }
-
-  transform(object, parents) {
-    if (!object.value) {
-      return;
-    }
-    if (
-      this.ignore.has(object.value) ||
-      object.value.includes(this.delimiter)
-    ) {
-      return;
-    }
-
-    if (
-      !parents[0] ||
-      (parents[0].type == "CallExpression" &&
-        parents[0].callee.type == "Identifier" &&
-        parents[0].callee.name == this.fnName)
-    ) {
-      return;
-    }
-
-    if (
-      !ComputeProbabilityMap(
-        this.options.stringCompression,
-        (x) => x,
-        object.value
-      )
-    ) {
-      return;
-    }
-
-    var index = this.map.get(object.value);
-
-    // New string, add it!
-    if (typeof index !== "number") {
-      // Ensure the string gets properly decoded
-      if (LZ_decode(LZ_encode(object.value)) !== object.value) {
-        this.ignore.add(object.value);
-        return;
-      }
-
-      index = this.map.size;
-      this.map.set(object.value, index);
-      this.string += object.value + this.delimiter;
-    }
-    ok(typeof index === "number");
-
-    return () => {
-      this.replaceIdentifierOrLiteral(
-        object,
-        CallExpression(Identifier(this.fnName), [Literal(index)]),
-        parents
-      );
-    };
-  }
-}
+  ensureComputedExpression,
+  prependProgram,
+} from "../../utils/ast-utils";
+import { numericLiteral } from "../../utils/node";
+import {
+  PakoInflateMin,
+  StringCompressionTemplate,
+} from "../../templates/stringCompressionTemplate";
+import Obfuscator from "../../obfuscator";
+import { createGetGlobalTemplate } from "../../templates/getGlobalTemplate";
+import { NO_RENAME } from "../../constants";
+const pako = require("pako");
+
+export default ({ Plugin }: PluginArg): PluginObject => {
+  const me = Plugin(Order.StringCompression, {
+    changeData: {
+      strings: 0,
+    },
+  });
+
+  const stringDelimiter = "|";
+
+  return {
+    visitor: {
+      Program: {
+        exit(programPath) {
+          const stringFn = me.getPlaceholder() + "_SC";
+          const stringMap = new Map<string, number>();
+
+          // Find all the strings
+          programPath.traverse({
+            StringLiteral: {
+              exit: (path) => {
+                const originalValue = path.node.value;
+
+                // Must be at least 3 characters long
+                if (originalValue.length < 3) return;
+
+                // Cannot contain the string delimiter
+                if (originalValue.includes(stringDelimiter)) return;
+
+                let index = stringMap.get(originalValue);
+                if (typeof index === "undefined") {
+                  // Allow user option to skip compression for certain strings
+                  if (
+                    !computeProbabilityMap(
+                      me.options.stringCompression,
+                      originalValue
+                    )
+                  ) {
+                    return;
+                  }
+
+                  index = stringMap.size;
+                  stringMap.set(originalValue, index);
+                }
+
+                me.changeData.strings++;
+
+                ensureComputedExpression(path);
+
+                path.replaceWith(
+                  t.callExpression(t.identifier(stringFn), [
+                    numericLiteral(index),
+                  ])
+                );
+              },
+            },
+          });
+
+          // No strings changed
+          if (stringMap.size === 0) return;
+
+          var stringPayload = Array.from(stringMap.keys()).join(
+            stringDelimiter
+          );
+
+          // Compress the string
+          var compressedBuffer: Uint8Array = pako.deflate(stringPayload);
+          var compressedBase64 =
+            Buffer.from(compressedBuffer).toString("base64");
+
+          let pakoName = me.obfuscator.getStringCompressionLibraryName();
+          let insertStringCompressionLibrary = !me.obfuscator.parentObfuscator;
+
+          prependProgram(
+            programPath,
+            StringCompressionTemplate.compile({
+              stringFn,
+              stringName: me.getPlaceholder(),
+              stringArray: me.getPlaceholder(),
+              stringDelimiter: () => t.stringLiteral(stringDelimiter),
+              stringValue: () => t.stringLiteral(compressedBase64),
+              GetGlobalTemplate: createGetGlobalTemplate(me, programPath),
+              getGlobalFnName: me.getPlaceholder(),
+              pakoName: pakoName,
+            })
+          );
+
+          if (insertStringCompressionLibrary) {
+            // RGF function should also clone the entire decompression function
+            prependProgram(
+              programPath,
+              Obfuscator.parseCode(PakoInflateMin.replace(/{pako}/g, pakoName))
+                .program.body
+            )[0]
+              .get("declarations")[0]
+              .get("id").node[NO_RENAME] = true;
+          }
+        },
+      },
+    },
+  };
+};