js-confuser 1.5.9 → 1.7.0

package/src/transforms/stack.ts

@@ -1,6 +1,4 @@
 import { ok } from "assert";
-import { stringify } from "querystring";
-import { reservedIdentifiers } from "../constants";
 import { ObfuscateOrder } from "../order";
 import { ComputeProbabilityMap } from "../probability";
 import Template from "../templates/template";
@@ -8,11 +6,11 @@ import { walk } from "../traverse";
 import {
   AssignmentExpression,
   BinaryExpression,
+  CallExpression,
   ExpressionStatement,
   Identifier,
   IfStatement,
   Literal,
-  Location,
   MemberExpression,
   Node,
   RestElement,
@@ -21,24 +19,29 @@ import {
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
 import {
+  computeFunctionLength,
+  getBlockBody,
   getDefiningContext,
   getReferencingContexts,
-  getVarContext,
   isForInitialize,
   isFunction,
   isVarContext,
   prepend,
 } from "../util/insert";
-import { choice, getRandomInteger, getRandomString } from "../util/random";
+import { chance, choice, getRandomInteger } from "../util/random";
 import Transform from "./transform";
+import { noRenameVariablePrefix } from "../constants";
+import { FunctionLengthTemplate } from "../templates/functionLength";
 
 export default class Stack extends Transform {
-  made: number;
+  mangledExpressionsMade: number;
+
+  functionLengthName: string;
 
   constructor(o) {
     super(o, ObfuscateOrder.Stack);
 
-    this.made = 0;
+    this.mangledExpressionsMade = 0;
   }
 
   match(object: Node, parents: Node[]) {
@@ -66,13 +69,42 @@ export default class Stack extends Transform {
         }
       }
 
+      // Don't apply to functions with 'use strict' directive
+      if (getBlockBody(object.body)[0]?.directive) {
+        return;
+      }
+
+      if (!ComputeProbabilityMap(this.options.stack)) {
+        return;
+      }
+
       var defined = new Set<string>();
       var referenced = new Set<string>();
       var illegal = new Set<string>();
 
+      /**
+       * Maps old names to new indices
+       */
       var subscripts = new Map<string, string>();
       var deadValues = Object.create(null);
 
+      var propertyGen = this.getGenerator();
+
+      function isTransformableFunction(functionNode: Node) {
+        if (functionNode.$requiresEval) return false;
+
+        // Check for 'this'
+        var isIllegal = false;
+        walk(functionNode.body, [], (o, p) => {
+          if (o.type === "ThisExpression") {
+            isIllegal = true;
+            return "EXIT";
+          }
+        });
+
+        return !isIllegal;
+      }
+
       function setSubscript(string, index) {
         subscripts.set(string, index + "");
       }
@@ -85,19 +117,30 @@ export default class Stack extends Transform {
       });
 
       var startingSize = subscripts.size;
+      var isIllegal = false;
 
       walk(object.body, [object, ...parents], (o, p) => {
+        if (o.type === "Identifier" && o.name === "arguments") {
+          isIllegal = true;
+          return "EXIT";
+        }
+
         if (o.type == "Identifier") {
           var info = getIdentifierInfo(o, p);
-          if (!info.spec.isReferenced) {
+          if (!info.spec.isReferenced || info.spec.isExported) {
             return;
           }
+
           var c = info.spec.isDefined
             ? getDefiningContext(o, p)
             : getReferencingContexts(o, p).find((x) => isVarContext(x));
 
           if (c !== object) {
-            this.log(o.name + " is illegal due to different context");
+            // this.log(o.name + " is illegal due to different context");
+            illegal.add(o.name);
+          }
+
+          if (o.name.startsWith(noRenameVariablePrefix)) {
             illegal.add(o.name);
           }
 
@@ -106,9 +149,9 @@ export default class Stack extends Transform {
             info.isFunctionParameter ||
             isForInitialize(o, p)
           ) {
-            this.log(
-              o.name + " is illegal due to clause parameter/function parameter"
-            );
+            // this.log(
+            //   o.name + " is illegal due to clause parameter/function parameter"
+            // );
             illegal.add(o.name);
           }
           if (o.hidden) {
@@ -121,27 +164,60 @@ export default class Stack extends Transform {
             }
 
             if (info.isFunctionDeclaration) {
-              if (p[0] !== object.body.body[0]) {
+              ok(p[0].type === "FunctionDeclaration");
+              if (
+                p[0] !== object.body.body[0] ||
+                !isTransformableFunction(p[0])
+              ) {
                 illegal.add(o.name);
               }
             }
 
-            setSubscript(o.name, subscripts.size);
+            // The new accessors will either be numbered: [index] or as a string .string
+            var newSubscript = choice([
+              subscripts.size,
+              propertyGen.generate(),
+            ]);
+
+            setSubscript(o.name, newSubscript);
             defined.add(o.name);
 
+            // Stack can only process single VariableDeclarations
             var varIndex = p.findIndex((x) => x.type == "VariableDeclaration");
-            if (
-              varIndex !== -1 &&
-              (varIndex !== 2 || p[varIndex].declarations.length > 1)
-            ) {
-              illegal.add(o.name);
+
+            if (varIndex !== -1) {
+              // Invalid 'id' property (must be Identifier)
+              if (varIndex !== 2) {
+                illegal.add(o.name);
+              } else if (p[varIndex].declarations.length > 1) {
+                illegal.add(o.name);
+              } else {
+                var value = p[varIndex].declarations[0].init;
+                if (value && !isTransformableFunction(value)) {
+                  illegal.add(o.name);
+                }
+              }
             }
           } else if (info.spec.isReferenced) {
+            if (info.spec.isModified) {
+              var assignmentIndex = p.findIndex(
+                (x) => x.type === "AssignmentExpression"
+              );
+              if (assignmentIndex !== -1) {
+                var value = p[assignmentIndex].right;
+                if (value && !isTransformableFunction(value)) {
+                  illegal.add(o.name);
+                }
+              }
+            }
+
             referenced.add(o.name);
           }
         }
       });
 
+      if (isIllegal) return;
+
       illegal.forEach((name) => {
         defined.delete(name);
         referenced.delete(name);
@@ -162,16 +238,17 @@ export default class Stack extends Transform {
         return;
       }
 
-      function numberLiteral(number, depth = 0) {
+      const numberLiteral = (number: number | string, depth = 0): Node => {
         ok(number === number);
         if (
           typeof number !== "number" ||
           !Object.keys(deadValues).length ||
-          depth > 5 ||
-          Math.random() > (depth == 0 ? 0.9 : 0.8 / (depth * 2))
+          depth > 4 ||
+          chance(75 + depth * 15 + this.mangledExpressionsMade / 25)
         ) {
           return Literal(number);
         }
+        this.mangledExpressionsMade++;
 
         var opposingIndex = choice(Object.keys(deadValues));
         if (typeof opposingIndex === "undefined") {
@@ -195,7 +272,7 @@ export default class Stack extends Transform {
           ),
           numberLiteral(actualValue - number, depth + 1)
         );
-      }
+      };
 
       function getMemberExpression(index) {
         ok(typeof index === "string", typeof index);
@@ -206,8 +283,7 @@ export default class Stack extends Transform {
         );
       }
 
-      var stackName = this.getPlaceholder();
-      var made = 1;
+      var stackName = this.getPlaceholder() + "_stack";
 
       const scan = (o, p) => {
         if (o.type == "Identifier") {
@@ -289,10 +365,9 @@ export default class Stack extends Transform {
           typeof o.value === "number" &&
           Math.floor(o.value) === o.value &&
           Math.abs(o.value) < 100_000 &&
-          Math.random() < 4 / made &&
-          p.find((x) => isFunction(x)) === object
+          p.find((x) => isFunction(x)) === object &&
+          chance(50)
         ) {
-          made++;
           return () => {
             this.replaceIdentifierOrLiteral(o, numberLiteral(o.value, 0), p);
           };
@@ -304,10 +379,10 @@ export default class Stack extends Transform {
       object.body.body.forEach((stmt, index) => {
         var isFirst = index == 0;
 
-        if (isFirst || Math.random() < 0.9 / index) {
+        if (isFirst || chance(50 - index * 10)) {
           var exprs = [];
 
-          var changes = getRandomInteger(isFirst ? 2 : 1, isFirst ? 3 : 2);
+          var changes = getRandomInteger(1, 3);
 
           for (var i = 0; i < changes; i++) {
             var expr;
@@ -320,8 +395,10 @@ export default class Stack extends Transform {
             var newIndex;
             var i = 0;
             do {
-              newIndex =
-                getRandomInteger(0, 250 + subscripts.size + i * 1000) + "";
+              newIndex = choice([
+                propertyGen.generate(),
+                getRandomInteger(0, 250 + subscripts.size + i * 1000) + "",
+              ]);
               i++;
             } while (valueSet.has(newIndex));
 
@@ -344,10 +421,10 @@ export default class Stack extends Transform {
                 break;
 
               case "deadValue":
-                var rand = getRandomInteger(-250, 250);
+                var rand = getRandomInteger(-150, 150);
 
                 // modify an already existing dead value index
-                if (Math.random() > 0.5) {
+                if (chance(50)) {
                   var alreadyExisting = choice(Object.keys(deadValues));
 
                   if (typeof alreadyExisting === "string") {
@@ -361,7 +438,6 @@ export default class Stack extends Transform {
                   numberLiteral(rand)
                 );
 
-                ok(!subscripts.has(newIndex));
                 deadValues[newIndex] = rand;
                 break;
             }
@@ -409,14 +485,58 @@ export default class Stack extends Transform {
         object.body.body.splice(parseInt(index) + i, 0, rotateNodes[index]);
       });
 
+      // Preserve function.length property
+      var originalFunctionLength = computeFunctionLength(object.params);
+
       // Set the params for this function to be the stack array
       object.params = [RestElement(Identifier(stackName))];
 
       // Ensure the array is correct length
       prepend(
         object.body,
-        Template(`${stackName}.length = ${startingSize}`).single()
+        Template(`${stackName}["length"] = ${startingSize}`).single()
       );
+
+      if (originalFunctionLength !== 0) {
+        if (!this.functionLengthName) {
+          this.functionLengthName = this.getPlaceholder();
+          prepend(
+            parents[parents.length - 1] || object,
+            FunctionLengthTemplate.single({ name: this.functionLengthName })
+          );
+        }
+
+        if (object.type === "FunctionDeclaration") {
+          var body = parents[0];
+          if (Array.isArray(body)) {
+            var index = body.indexOf(object);
+
+            body.splice(
+              index,
+              0,
+              ExpressionStatement(
+                CallExpression(Identifier(this.functionLengthName), [
+                  Identifier(object.id.name),
+                  Literal(originalFunctionLength),
+                ])
+              )
+            );
+          }
+        } else {
+          ok(
+            object.type === "FunctionExpression" ||
+              object.type === "ArrowFunctionExpression"
+          );
+
+          this.replace(
+            object,
+            CallExpression(Identifier(this.functionLengthName), [
+              { ...object },
+              Literal(originalFunctionLength),
+            ])
+          );
+        }
+      }
     };
   }
 }

package/src/transforms/string/encoding.ts

@@ -7,7 +7,120 @@ const Encoding: {
     template: ReturnType<typeof Template>;
   };
 } = {
-  ascii85: {
+  base91: {
+    encode(str) {
+      const table =
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
+
+      const raw = Buffer.from(str, "utf-8");
+      const len = raw.length;
+      let ret = "";
+
+      let n = 0;
+      let b = 0;
+
+      for (let i = 0; i < len; i++) {
+        b |= raw[i] << n;
+        n += 8;
+
+        if (n > 13) {
+          let v = b & 8191;
+          if (v > 88) {
+            b >>= 13;
+            n -= 13;
+          } else {
+            v = b & 16383;
+            b >>= 14;
+            n -= 14;
+          }
+          ret += table[v % 91] + table[(v / 91) | 0];
+        }
+      }
+
+      if (n) {
+        ret += table[b % 91];
+        if (n > 7 || b > 90) ret += table[(b / 91) | 0];
+      }
+
+      return ret;
+    },
+    decode(str) {
+      const table =
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
+
+      const raw = "" + (str || "");
+      const len = raw.length;
+      const ret = [];
+
+      let b = 0;
+      let n = 0;
+      let v = -1;
+
+      for (let i = 0; i < len; i++) {
+        const p = table.indexOf(raw[i]);
+        if (p === -1) continue;
+        if (v < 0) {
+          v = p;
+        } else {
+          v += p * 91;
+          b |= v << n;
+          n += (v & 8191) > 88 ? 13 : 14;
+          do {
+            ret.push(b & 0xff);
+            b >>= 8;
+            n -= 8;
+          } while (n > 7);
+          v = -1;
+        }
+      }
+
+      if (v > -1) {
+        ret.push((b | (v << n)) & 0xff);
+      }
+
+      return Buffer.from(ret).toString("utf-8");
+    },
+    template: Template(`  
+      function {name}(str){
+        const table =
+          'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_\`{|}~"';
+
+        const raw = "" + (str || "");
+        const len = raw.length;
+        const ret = [];
+
+        let b = 0;
+        let n = 0;
+        let v = -1;
+
+        for (let i = 0; i < len; i++) {
+          const p = table.indexOf(raw[i]);
+          if (p === -1) continue;
+          if (v < 0) {
+            v = p;
+          } else {
+            v += p * 91;
+            b |= v << n;
+            n += (v & 8191) > 88 ? 13 : 14;
+            do {
+              ret.push(b & 0xff);
+              b >>= 8;
+              n -= 8;
+            } while (n > 7);
+            v = -1;
+          }
+        }
+
+        if (v > -1) {
+          ret.push((b | (v << n)) & 0xff);
+        }
+
+        return {bufferToString}(ret);
+      }
+    `),
+  },
+
+  /* ascii85: { This implementation is flaky and causes decoding errors 
     encode(a) {
       var b, c, d, e, f, g, h, i, j, k;
       // @ts-ignore
@@ -94,217 +207,7 @@ const Encoding: {
       }(e, c[l]), h[LL[0]][LL[1]](h, e);
     }
     `),
-  },
-
-  base32: {
-    encode: function (s) {
-      var a = "!\"#$%&'()*+,-./0123456789:;<=>?@";
-      var len = s.length;
-      var o = "";
-      var w,
-        c,
-        r = 0,
-        sh = 0,
-        i;
-      for (i = 0; i < len; i += 5) {
-        // mask top 5 bits
-        c = s.charCodeAt(i);
-        w = 0xf8 & c;
-        o += a.charAt(w >> 3);
-        r = 0x07 & c;
-        sh = 2;
-
-        if (i + 1 < len) {
-          c = s.charCodeAt(i + 1);
-          // mask top 2 bits
-          w = 0xc0 & c;
-          o += a.charAt((r << 2) + (w >> 6));
-          o += a.charAt((0x3e & c) >> 1);
-          r = c & 0x01;
-          sh = 4;
-        }
-
-        if (i + 2 < len) {
-          c = s.charCodeAt(i + 2);
-          // mask top 4 bits
-          w = 0xf0 & c;
-          o += a.charAt((r << 4) + (w >> 4));
-          r = 0x0f & c;
-          sh = 1;
-        }
-
-        if (i + 3 < len) {
-          c = s.charCodeAt(i + 3);
-          // mask top 1 bit
-          w = 0x80 & c;
-          o += a.charAt((r << 1) + (w >> 7));
-          o += a.charAt((0x7c & c) >> 2);
-          r = 0x03 & c;
-          sh = 3;
-        }
-
-        if (i + 4 < len) {
-          c = s.charCodeAt(i + 4);
-          // mask top 3 bits
-          w = 0xe0 & c;
-          o += a.charAt((r << 3) + (w >> 5));
-          o += a.charAt(0x1f & c);
-          r = 0;
-          sh = 0;
-        }
-      }
-      // Calculate length of pad by getting the
-      // number of words to reach an 8th octet.
-      if (r != 0) {
-        o += a.charAt(r << sh);
-      }
-      return o;
-    },
-    decode: function (s) {
-      var v,
-        x,
-        bits = 0,
-        o = "",
-        len = s.length,
-        d = String,
-        e = "charCodeAt",
-        f = "fromCharCode",
-        i;
-
-      for (i = 0; i < len; i += 1) {
-        (v = s[e](i) - 33),
-          v >= 0 && v < 32
-            ? ((bits += ((x = (x << 5) | v), 5)),
-              bits >= 8
-                ? (bits -= ((o += d[f]((x >> (bits - 8)) & 0xff)), 8))
-                : 0)
-            : 0;
-      }
-      return o;
-    },
-    template: Template(`
-    function {name}(s) {
-      var v,
-        x,
-        b = 0,
-        o = "",
-        len = s.length,
-        d = String,
-        e = "charCodeAt",
-        f = "fromCharCode", i;
-  
-      for (i = 0; i < len; i += 1) {
-        (v = s[e](i) - 33),
-          v >= 0 && v < 32
-            ? ((b += ((x = (x << 5) | v), 5)),
-              b >= 8
-                ? (b -= ((o += d[f]((x >> (b - 8)) & 0xff)), 8))
-                : 0)
-            : 0;
-      }
-      return o;
-    }
-    `),
-  },
-
-  hexTable: {
-    encode: function (str) {
-      var output = "";
-
-      for (var j = 0; j < str.length; j += 3) {
-        var chunk = str.substring(j, j + 3);
-        if (!chunk) {
-          continue;
-        }
-
-        chunk = chunk + "~";
-
-        var uniqueChars = new Set([]);
-        for (var char of chunk) {
-          uniqueChars.add(char);
-        }
-
-        var keys = Array.from(uniqueChars).sort();
-        var table = {},
-          i = 0;
-        for (var key of keys) {
-          table[key] = i++;
-        }
-
-        var idx = [];
-        for (var char of chunk) {
-          idx.push(table[char]);
-        }
-
-        var table64 = "0x";
-        for (var i = keys.length - 1; i >= 0; i--) {
-          table64 += keys[i].charCodeAt(0).toString(16).toUpperCase();
-        }
-
-        var idxInt = 0;
-        for (var i = idx.length - 1; i >= 0; i--) {
-          idxInt = (idxInt << 3) | idx[i];
-        }
-
-        var idx64 = "0x" + idxInt.toString(16).toUpperCase();
-
-        // console.log(chunk, table, idx, table64, idx64);
-
-        output += table64 + "," + idx64 + ",";
-      }
-
-      if (output.endsWith(",")) {
-        output = output.substring(0, output.length - 1);
-      }
-
-      return "{" + output + "}";
-    },
-
-    decode: function (str) {
-      var output = "";
-
-      str = str.substring(1, str.length - 1);
-      var chunks = str.split(",");
-
-      for (var i = 0; i < chunks.length; i += 2) {
-        var arr = [chunks[i], chunks[i + 1]];
-
-        var [table, idx] = arr.map(Number);
-
-        // console.log(table, idx);
-        while (idx) {
-          output += String.fromCharCode((table >> (8 * (idx & 7))) & 0xff);
-          idx >>= 3;
-        }
-      }
-
-      return output.replace(/~/g, "");
-    },
-
-    template: Template(`
-      function {name}(str){
-        var output = "";
-    
-        str = str.substring(1, str.length - 1);
-        var chunks = str.split(",");
-      
-        for (var i = 0; i < chunks.length; i += 2) {
-          var arr = [chunks[i], chunks[i + 1]];
-      
-          var [table, idx] = arr.map(Number);
-      
-          // console.log(table, idx);
-          while (idx) {
-            output += String.fromCharCode((table >> (8 * (idx & 7))) & 0xff);
-            idx >>= 3;
-          }
-        }
-      
-        return output.replace(/~/g, "");
-      }
-    
-    `),
-  },
+  }, */
 };
 
 export default Encoding;