Improve String Compression string creation

Author: MichaelXF

CHANGELOG.md

@@ -28,6 +28,8 @@ eval('console.log(' + 'CA1HU0' + ')');
 
 - Pad the `String Concealing` array with more fake strings
 
+- Improve `String Compression`
+
 - New Web UI sneak peak: https://new--confuser.netlify.app/
 
 

docs/TamperProtection.md

@@ -73,7 +73,7 @@ Eval loses it's local scope access when redefined by a monkey-patched function.
 
 ### Custom Implementation
 
-You can provide a custom implementation for `lock.tamperProtection` to control which functions get changed.
+You can provide a custom implementation for `lock.tamperProtection` to control which functions get the native function check.
 
 ```js
 {

src/transforms/string/stringCompression.ts

@@ -4,19 +4,33 @@ import { ComputeProbabilityMap } from "../../probability";
 import Template from "../../templates/template";
 import { isDirective, isModuleSource } from "../../util/compare";
 import {
+  AssignmentExpression,
+  BinaryExpression,
   CallExpression,
+  ExpressionStatement,
   FunctionDeclaration,
   FunctionExpression,
   Identifier,
+  IfStatement,
   Literal,
   MemberExpression,
+  ObjectExpression,
+  Property,
   ReturnStatement,
   VariableDeclaration,
   VariableDeclarator,
 } from "../../util/gen";
 import { append, prepend } from "../../util/insert";
 import Transform from "../transform";
 import { predictableFunctionTag } from "../../constants";
+import {
+  chance,
+  choice,
+  getRandomFalseExpression,
+  getRandomInteger,
+  getRandomString,
+  splitIntoChunks,
+} from "../../util/random";
 
 function LZ_encode(c) {
   ok(c);
@@ -141,15 +155,72 @@ export default class StringCompression extends Transform {
       )
     );
 
-    append(
-      tree,
-      FunctionDeclaration(
-        getStringName,
-        [],
-        [ReturnStatement(Literal(encoded))]
-      )
+    var keys = new Set<string>();
+    var keysToMake = getRandomInteger(4, 14);
+    for (var i = 0; i < keysToMake; i++) {
+      keys.add(getRandomString(getRandomInteger(4, 14)));
+    }
+
+    var objectExpression = ObjectExpression(
+      Array.from(keys).map((key) => {
+        return Property(Literal(key), getRandomFalseExpression(), true);
+      })
+    );
+
+    // Get string function
+    var getStringBody = [];
+    var splits = splitIntoChunks(
+      encoded,
+      Math.floor(encoded.length / getRandomInteger(3, 6))
+    );
+
+    getStringBody.push(
+      VariableDeclaration(VariableDeclarator("str", Literal(splits.shift())))
+    );
+
+    getStringBody.push(
+      VariableDeclaration(VariableDeclarator("objectToTest", objectExpression))
     );
 
+    const addIfStatement = (testingFor, literalValueToBeAppended) => {
+      getStringBody.push(
+        IfStatement(
+          BinaryExpression(
+            "in",
+            Literal(testingFor),
+            Identifier("objectToTest")
+          ),
+          [
+            ExpressionStatement(
+              AssignmentExpression(
+                "+=",
+                Identifier("str"),
+                Literal(literalValueToBeAppended)
+              )
+            ),
+          ]
+        )
+      );
+    };
+
+    for (const split of splits) {
+      if (chance(50)) {
+        var fakeKey;
+        do {
+          fakeKey = getRandomString(getRandomInteger(4, 14));
+        } while (keys.has(fakeKey) || fakeKey in {});
+
+        addIfStatement(fakeKey, getRandomString(split.length));
+      }
+
+      addIfStatement(choice(Array.from(keys)), split);
+    }
+
+    // Return computed string
+    getStringBody.push(ReturnStatement(Identifier("str")));
+
+    append(tree, FunctionDeclaration(getStringName, [], getStringBody));
+
     append(
       tree,
       FunctionDeclaration(

src/util/random.ts

@@ -63,7 +63,7 @@ export function splitIntoChunks(str: string, size: number) {
   ok(Math.floor(size) === size, "size must be integer");
 
   const numChunks = Math.ceil(str.length / size);
-  const chunks = new Array(numChunks);
+  const chunks: string[] = new Array(numChunks);
 
   for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
     chunks[i] = str.substr(o, size);