js-confuser 1.5.1 → 1.5.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+# `1.5.2`
+Mini fixes
+
+- Fixed [#41](https://github.com/MichaelXF/js-confuser/issues/41)
+- - Obfuscator mishandled switch statements with a `default` case
+
+- Fixed [#43](https://github.com/MichaelXF/js-confuser/issues/43)
+- - Obfuscator mishandled variable destructuring in for-loops
+
 # `1.5.1`
 Object Extraction Fix
 

package/dist/transforms/controlFlowFlattening/switchCaseObfuscation.js

@@ -28,7 +28,7 @@ class SwitchCaseObfuscation extends _transform.default {
   }
 
   match(object, parents) {
-    return object.type == "SwitchStatement" && !object.cases.find(x => !(x.test.type == "Literal" && typeof x.test.value === "number" && Math.abs(x.test.value) < 100000));
+    return object.type == "SwitchStatement" && !object.cases.find(x => !(x.test && typeof x.test === "object" && x.test.type == "Literal" && typeof x.test.value === "number" && Math.abs(x.test.value) < 100000));
   }
 
   transform(object, parents) {

package/dist/transforms/minify.js

@@ -457,7 +457,7 @@ class Minify extends _transform.default {
       } // check for redundant patterns
 
 
-      if (object.id.type == "ArrayPattern" && object.init.type == "ArrayExpression") {
+      if (object.id.type == "ArrayPattern" && object.init && typeof object.init === "object" && object.init.type == "ArrayExpression") {
         if (object.id.elements.length == 1 && object.init.elements.length == 1) {
           object.id = object.id.elements[0];
           object.init = object.init.elements[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/transforms/controlFlowFlattening/switchCaseObfuscation.ts

@@ -27,6 +27,8 @@ export default class SwitchCaseObfuscation extends Transform {
       !object.cases.find(
         (x) =>
           !(
+            x.test &&
+            typeof x.test === "object" &&
             x.test.type == "Literal" &&
             typeof x.test.value === "number" &&
             Math.abs(x.test.value) < 100_000

package/src/transforms/minify.ts

@@ -595,6 +595,8 @@ export default class Minify extends Transform {
       // check for redundant patterns
       if (
         object.id.type == "ArrayPattern" &&
+        object.init &&
+        typeof object.init === "object" &&
         object.init.type == "ArrayExpression"
       ) {
         if (

package/test/transforms/controlFlowFlattening/switchCaseObfuscation.test.ts

@@ -74,3 +74,47 @@ it("should not obfuscate switch statements with complex discriminants (SwitchCas
 
   eval(output);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/41
+it("Not apply to switch statements with default cases", async ()=>{
+
+    var code = `
+    var array = [];
+
+    function runOnce(stateParam){
+      switch(stateParam){
+        case 1: array.push(1, 2, 3); break;
+        case 2: array.push(4, 5, 6); break;
+        case 3: array.push(7, 8, 9); break;
+        default: array.push(10); break;
+      }
+    }
+
+    runOnce(1);
+    runOnce(2);
+    runOnce(3);
+    runOnce(-1); // default case
+
+    input(array);
+  `;
+
+  var output = await JsConfuser(code, {
+    target: "browser",
+    controlFlowFlattening: true,
+  });
+
+  expect(
+    output.includes("case 1:") &&
+      output.includes("case 2:") &&
+      output.includes("case 3:") 
+  ).toStrictEqual(true);
+
+  function input(array) {
+    expect(array).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  }
+
+  eval(output);
+
+
+
+});

package/test/transforms/minify.test.ts

@@ -299,3 +299,25 @@ test("Variant #15: Removing implied 'return'", async () => {
 
   expect(output2).toContain("return");
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/43
+test("Variant #16: Handle deconstructuring in for loop", async ()=>{
+// Valid
+var output = await JsConfuser(
+    `
+    for(const [a] of [[1]]) {
+        input(a);
+    }
+  `,
+    { target: "node", minify: true }
+  );
+
+  var value;
+  function input(valueIn){
+    value = valueIn;
+  }
+
+  eval(output);
+
+  expect(value).toStrictEqual(1);
+})