js-confuser 1.7.3 → 2.0.0-alpha.0

package/src/transforms/shuffle.ts

@@ -1,254 +1,80 @@
-import { ok } from "assert";
-import { ObfuscateOrder } from "../order";
-import { ComputeProbabilityMap } from "../probability";
-import Template from "../templates/template";
-import {
-  BinaryExpression,
-  CallExpression,
-  ExpressionStatement,
-  ForStatement,
-  FunctionExpression,
-  Identifier,
-  Literal,
-  MemberExpression,
-  ReturnStatement,
-  UpdateExpression,
-  VariableDeclaration,
-  VariableDeclarator,
-} from "../util/gen";
-import { clone, prepend } from "../util/insert";
-import { getRandomInteger } from "../util/random";
-import Transform from "./transform";
-
-var Hash = function (s) {
-  var a = 1,
-    c = 0,
-    h,
-    o;
-  if (s) {
-    a = 0;
-    for (h = s.length - 1; h >= 0; h--) {
-      o = s.charCodeAt(h);
-      a = ((a << 6) & 268435455) + o + (o << 14);
-      c = a & 266338304;
-      a = c !== 0 ? a ^ (c >> 21) : a;
-    }
-  }
-  return ~~String(a).slice(0, 3);
-};
-
-var HashTemplate = new Template(
-  `
-  var {name} = function(arr) {
-    var s = arr.map(x=>x+"").join(''), a = 1, c = 0, h, o;
-    if (s) {
-        a = 0;
-        for (h = s.length - 1; h >= 0; h--) {
-            o = s.charCodeAt(h);
-            a = (a<<6&268435455) + o + (o<<14);
-            c = a & 266338304;
-            a = c!==0?a^c>>21:a;
-        }
-    }
-    return ~~String(a).slice(0, 3);
-};`
-);
-
-/**
- * Shuffles arrays initial order of elements.
- *
- * "Un-shuffles" the array at runtime.
- */
-export default class Shuffle extends Transform {
-  hashName: string;
-  constructor(o) {
-    super(o, ObfuscateOrder.Shuffle);
-  }
-
-  match(object, parents) {
-    return (
-      object.type == "ArrayExpression" &&
-      !parents.find((x) => x.$multiTransformSkip)
-    );
-  }
-
-  transform(object, parents) {
-    return () => {
-      if (object.elements.length < 3) {
-        // Min: 4 elements
-        return;
-      }
-
-      function isAllowed(e) {
-        return (
-          e.type == "Literal" &&
-          { number: 1, boolean: 1, string: 1 }[typeof e.value]
-        );
-      }
-
-      // Only arrays with only literals
-      var illegal = object.elements.find((x) => !isAllowed(x));
-
-      if (illegal) {
-        return;
-      }
-
-      var mapped = object.elements.map((x) => x.value);
-
-      var mode = ComputeProbabilityMap(this.options.shuffle, (x) => x, mapped);
-      if (mode) {
-        var shift = getRandomInteger(
-          1,
-          Math.min(60, object.elements.length * 6)
-        );
-
-        var expr = Literal(shift);
-        var name = this.getPlaceholder();
-
-        if (mode == "hash") {
-          var str = mapped.join("");
-          shift = Hash(str);
-
-          if (!this.hashName) {
-            prepend(
-              parents[parents.length - 1],
-              HashTemplate.single({
-                name: (this.hashName = this.getPlaceholder()),
-              })
-            );
-          }
-
-          for (var i = 0; i < shift; i++) {
-            object.elements.push(object.elements.shift());
-          }
-
-          var shiftedHash = Hash(
-            object.elements.map((x) => x.value + "").join("")
-          );
-
-          expr = BinaryExpression(
-            "-",
-            CallExpression(Identifier(this.hashName), [Identifier(name)]),
-            Literal(shiftedHash - shift)
-          );
-        } else {
-          for (var i = 0; i < shift; i++) {
-            object.elements.push(object.elements.shift());
-          }
-        }
-
-        var code = [];
-
-        var iName = this.getPlaceholder();
-
-        var inPlace = false;
-        var inPlaceName;
-        var inPlaceBody;
-        var inPlaceIndex;
-
-        var varDeclarator = parents[0];
-        if (varDeclarator.type == "VariableDeclarator") {
-          var varDec = parents[2];
-          if (varDec.type == "VariableDeclaration" && varDec.kind !== "const") {
-            var body = parents[3];
-            if (
-              varDec.declarations.length == 1 &&
-              Array.isArray(body) &&
-              varDeclarator.id.type === "Identifier" &&
-              varDeclarator.init === object
-            ) {
-              inPlaceIndex = body.indexOf(varDec);
-              inPlaceBody = body;
-              inPlace = inPlaceIndex !== -1;
-              inPlaceName = varDeclarator.id.name;
-            }
-          }
-        }
-
-        if (mode !== "hash") {
-          var varPrefix = this.getPlaceholder();
-          code.push(
-            new Template(`
-            for ( var ${varPrefix}x = 16; ${varPrefix}x%4 === 0; ${varPrefix}x++) {
-              var ${varPrefix}z = 0;
-              ${
-                inPlace ? `${inPlaceName} = ${name}` : name
-              } = ${name}.concat((function(){
-                ${varPrefix}z++;
-                if(${varPrefix}z === 1){
-                  return [];
-                }
-
-                for( var ${varPrefix}i = ${getRandomInteger(
-              5,
-              105
-            )}; ${varPrefix}i; ${varPrefix}i-- ){
-                  ${name}.unshift(${name}.pop());
-                }
-                return [];
-              })());
-            }
-            `).single()
-          );
-        }
-
-        code.push(
-          ForStatement(
-            VariableDeclaration(VariableDeclarator(iName, expr)),
-            Identifier(iName),
-            UpdateExpression("--", Identifier(iName), false),
-            [
-              // ${name}.unshift(${name}.pop());
-              ExpressionStatement(
-                CallExpression(
-                  MemberExpression(
-                    Identifier(name),
-                    Identifier("unshift"),
-                    false
-                  ),
-                  [
-                    CallExpression(
-                      MemberExpression(
-                        Identifier(name),
-                        Identifier("pop"),
-                        false
-                      ),
-                      []
-                    ),
-                  ]
-                )
-              ),
-            ]
-          )
-        );
-
-        if (inPlace) {
-          var varDeclarator = parents[0];
-          ok(i != -1);
-
-          inPlaceBody.splice(
-            inPlaceIndex + 1,
-            0,
-            VariableDeclaration(
-              VariableDeclarator(name, Identifier(varDeclarator.id.name))
-            ),
-            ...code
-          );
-        }
-
-        if (!inPlace) {
-          this.replace(
-            object,
-            CallExpression(
-              FunctionExpression(
-                [Identifier(name)],
-                [...code, ReturnStatement(Identifier(name))]
-              ),
-              [clone(object)]
-            )
-          );
-        }
-      }
-    };
-  }
-}
+import { NodePath } from "@babel/core";
+import { PluginArg, PluginObject } from "./plugin";
+import * as t from "@babel/types";
+import { computeProbabilityMap } from "../probability";
+import { getRandomInteger } from "../utils/random-utils";
+import Template from "../templates/template";
+import { Order } from "../order";
+import { isStaticValue } from "../utils/static-utils";
+import { NodeSymbol, PREDICTABLE } from "../constants";
+import { numericLiteral } from "../utils/node";
+
+export default ({ Plugin }: PluginArg): PluginObject => {
+  const me = Plugin(Order.Shuffle, {
+    changeData: {
+      arrays: 0,
+    },
+  });
+
+  return {
+    visitor: {
+      ArrayExpression: {
+        exit(path) {
+          if (path.node.elements.length <= 3) {
+            return;
+          }
+          var illegalElement = path.node.elements.find(
+            (element) => !isStaticValue(element)
+          );
+
+          if (illegalElement) return;
+
+          if (!computeProbabilityMap(me.options.shuffle)) {
+            return;
+          }
+
+          var shift = getRandomInteger(
+            1,
+            Math.min(30, path.node.elements.length * 6)
+          );
+
+          var shiftedElements = [...path.node.elements];
+          for (var i = 0; i < shift; i++) {
+            shiftedElements.unshift(shiftedElements.pop());
+          }
+
+          var block = path.find((p) => p.isBlock()) as NodePath<t.Block>;
+
+          var functionExpression = new Template(
+            `
+          (function(arr) {
+            for (var i = 0; i < {shiftNode}; i++) {
+              arr.push(arr.shift());
+            }
+            return arr;
+          })
+          `
+          ).expression<t.FunctionExpression>({
+            shiftNode: numericLiteral(shift),
+          });
+
+          (functionExpression as NodeSymbol)[PREDICTABLE] = true;
+
+          var memberExpression = me
+            .getControlObject(block)
+            .addProperty(functionExpression);
+
+          path.replaceWith(
+            t.callExpression(memberExpression, [
+              t.arrayExpression(shiftedElements),
+            ])
+          );
+
+          path.skip();
+
+          me.changeData.arrays++;
+        },
+      },
+    },
+  };
+};

package/src/transforms/string/encoding.ts

@@ -1,45 +1,33 @@
+import { CustomStringEncoding } from "../../options";
 import Template from "../../templates/template";
-import { Literal } from "../../util/gen";
-import { choice, shuffle } from "../../util/random";
-
-/**
- * Defines an encoding implementation the Obfuscator
- */
-export interface EncodingImplementation {
-  identity: string;
-
-  encode(s: string): string;
-  decode(s: string): string;
-  template: Template;
-}
+import { choice, shuffle } from "../../utils/random-utils";
+import * as t from "@babel/types";
 
-let _hasAllEncodings = false;
-export function hasAllEncodings() {
-  return _hasAllEncodings;
-}
+let hasAllEncodings = false;
 
-export function createEncodingImplementation(): EncodingImplementation {
-  if (_hasAllEncodings) {
-    return EncodingImplementations[
-      choice(Object.keys(EncodingImplementations))
-    ];
+export function createDefaultStringEncoding(
+  encodingImplementations
+): CustomStringEncoding {
+  if (hasAllEncodings) {
+    return null;
   }
 
-  // create base91 encoding
+  // Create base91 encoding
   let strTable =
     'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
 
-  // shuffle table
+  // Randomize the charset
   strTable = shuffle(strTable.split("")).join("");
 
   let identity = "base91_" + strTable;
 
-  if (EncodingImplementations.hasOwnProperty(identity)) {
-    _hasAllEncodings = true;
-    return EncodingImplementations[identity];
+  // Check if the encoding already exists
+  if (typeof encodingImplementations[identity] !== "undefined") {
+    hasAllEncodings = true;
+    return null;
   }
 
-  var encodingImplementation = {
+  var encodingImplementation: CustomStringEncoding = {
     identity,
     encode(str) {
       const table = strTable;
@@ -111,8 +99,8 @@ export function createEncodingImplementation(): EncodingImplementation {
 
       return Buffer.from(ret).toString("utf-8");
     },
-    template: new Template(`  
-        function {__fnName__}(str){
+    code: new Template(`  
+        function {fnName}(str){
           var table = {__strTable__};
   
           var raw = "" + (str || "");
@@ -145,106 +133,12 @@ export function createEncodingImplementation(): EncodingImplementation {
             ret.push((b | (v << n)) & 0xff);
           }
   
-          return {__bufferToString__}(ret);
+          return {__bufferToStringFunction__}(ret);
         }
       `).setDefaultVariables({
-      __strTable__: Literal(strTable),
+      __strTable__: t.stringLiteral(strTable),
     }),
   };
 
-  EncodingImplementations[identity] = encodingImplementation;
   return encodingImplementation;
 }
-
-export const EncodingImplementations: {
-  [encodingIdentity: string]: EncodingImplementation;
-} = {
-  /* ascii85: { This implementation is flaky and causes decoding errors 
-    encode(a) {
-      var b, c, d, e, f, g, h, i, j, k;
-      // @ts-ignore
-      for (
-        // @ts-ignore
-        !/[^\x00-\xFF]/.test(a),
-          b = "\x00\x00\x00\x00".slice(a.length % 4 || 4),
-          a += b,
-          c = [],
-          d = 0,
-          e = a.length;
-        e > d;
-        d += 4
-      )
-        (f =
-          (a.charCodeAt(d) << 24) +
-          (a.charCodeAt(d + 1) << 16) +
-          (a.charCodeAt(d + 2) << 8) +
-          a.charCodeAt(d + 3)),
-          0 !== f
-            ? ((k = f % 85),
-              (f = (f - k) / 85),
-              (j = f % 85),
-              (f = (f - j) / 85),
-              (i = f % 85),
-              (f = (f - i) / 85),
-              (h = f % 85),
-              (f = (f - h) / 85),
-              (g = f % 85),
-              c.push(g + 33, h + 33, i + 33, j + 33, k + 33))
-            : c.push(122);
-      return (
-        (function (a, b) {
-          for (var c = b; c > 0; c--) a.pop();
-        })(c, b.length),
-        "<~" + String.fromCharCode.apply(String, c) + "~>"
-      );
-    },
-    decode(a) {
-      var c,
-        d,
-        e,
-        f,
-        g,
-        h = String,
-        l = "length",
-        w = 255,
-        x = "charCodeAt",
-        y = "slice",
-        z = "replace";
-      for (
-        "<~" === a[y](0, 2) && "~>" === a[y](-2),
-          a = a[y](2, -2)[z](/s/g, "")[z]("z", "!!!!!"),
-          c = "uuuuu"[y](a[l] % 5 || 5),
-          a += c,
-          e = [],
-          f = 0,
-          g = a[l];
-        g > f;
-        f += 5
-      )
-        (d =
-          52200625 * (a[x](f) - 33) +
-          614125 * (a[x](f + 1) - 33) +
-          7225 * (a[x](f + 2) - 33) +
-          85 * (a[x](f + 3) - 33) +
-          (a[x](f + 4) - 33)),
-          e.push(w & (d >> 24), w & (d >> 16), w & (d >> 8), w & d);
-      return (
-        (function (a, b) {
-          for (var c = b; c > 0; c--) a.pop();
-        })(e, c[l]),
-        h.fromCharCode.apply(h, e)
-      );
-    },
-    template: Template(`
-    function {name}(a, LL = ["fromCharCode", "apply"]) {
-      var c, d, e, f, g, h = String, l = "length", w = 255, x = "charCodeAt", y = "slice", z = "replace";
-      for ("<~" === a[y](0, 2) && "~>" === a[y](-2), a = a[y](2, -2)[z](/\s/g, "")[z]("z", "!!!!!"), 
-      c = "uuuuu"[y](a[l] % 5 || 5), a += c, e = [], f = 0, g = a[l]; g > f; f += 5) d = 52200625 * (a[x](f) - 33) + 614125 * (a[x](f + 1) - 33) + 7225 * (a[x](f + 2) - 33) + 85 * (a[x](f + 3) - 33) + (a[x](f + 4) - 33), 
-      e.push(w & d >> 24, w & d >> 16, w & d >> 8, w & d);
-      return function(a, b) {
-        for (var c = b; c > 0; c--) a.pop();
-      }(e, c[l]), h[LL[0]][LL[1]](h, e);
-    }
-    `),
-  }, */
-};