Fixed NumbersToExpressions Edge Case!

Updated Strong preset to use NEW NumberRespresentationMutation! eg 0 -> 0x0, 0e0, etc. Binary Representation is available but disabled by default. Even then you'll get a warning in logger making sure you know it won't run on lua5.1. It will run on Luau & LuaJIT though! Also added opaque boolean representation to the compiler. Added swapping to for statement handling in the compiler and also fixed duplicate local name in while_statement.lua. Finally... The new default for ConstantArray is now mixed! the first character is a prefix and tells it if it should decode base64 or base85. dont worry, i already made sure both characters are NEVER the same.

Author: SpinnySpiwal

src/presets.lua

@@ -28,7 +28,7 @@ return {
 				Name = "ConstantArray",
 				Settings = {
 					Threshold = 1,
-					StringsOnly = true,
+					StringsOnly = true
 				},
 			},
 			{ Name = "WrapInFunction", Settings = {} },
@@ -105,10 +105,15 @@ return {
 					StringsOnly = true,
 					Shuffle = true,
 					Rotate = true,
-					LocalWrapperThreshold = 0,
+					LocalWrapperThreshold = 0
+				},
+			},
+			{
+				Name = "NumbersToExpressions",
+				Settings = {
+					NumberRepresentationMutaton = true
 				},
 			},
-			{ Name = "NumbersToExpressions", Settings = {} },
 			{ Name = "WrapInFunction", Settings = {} },
 		},
 	},

src/prometheus/compiler/expressions/boolean.lua

@@ -5,14 +5,42 @@
 -- This Script contains the expression handler for the BooleanExpression.
 
 local Ast = require("prometheus.ast");
+local function createRandomASTCFlowExpression(resultBool)
+    local expTB = {
+        Ast.GreaterThanExpression,
+        Ast.LessThanExpression,
+        Ast.GreaterThanOrEqualsExpression,
+        Ast.LessThanOrEqualsExpression,
+        Ast.NotEqualsExpression
+    }
 
-return function(self, expression, funcDepth, numReturns)
+    local expLookup = {
+        [Ast.GreaterThanExpression] = ">";
+        [Ast.LessThanExpression] = "<";
+        [Ast.GreaterThanOrEqualsExpression] = ">=";
+        [Ast.LessThanOrEqualsExpression] = "<=";
+        [Ast.NotEqualsExpression] = "~=";
+    }
+
+    local leftInt, rightInt, boolResult, r3, randomExp
+    repeat
+        randomExp = expTB[math.random(1, #expTB)]
+        leftInt = Ast.NumberExpression(math.random(1, 2^24))
+        rightInt = Ast.NumberExpression(math.random(1, 2^24))
+        r3 = "return " .. leftInt.value .. expLookup[randomExp] .. rightInt.value
+        boolResult = loadstring(r3)()
+    until boolResult == resultBool
+
+    return randomExp(leftInt, rightInt, false)
+end
+
+return function(self, expression, _, numReturns)
     local scope = self.activeBlock.scope;
     local regs = {};
     for i = 1, numReturns do
         regs[i] = self:allocRegister();
         if i == 1 then
-            self:addStatement(self:setRegister(scope, regs[i], Ast.BooleanExpression(expression.value)), {regs[i]}, {}, false);
+            self:addStatement(self:setRegister(scope, regs[i], createRandomASTCFlowExpression(expression.value)), {regs[i]}, {}, false);
         else
             self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
         end

src/prometheus/compiler/statements/for_statement.lua

@@ -5,6 +5,7 @@
 -- This Script contains the statement handler for the ForStatement
 
 local Ast = require("prometheus.ast");
+local util = require("prometheus.util");
 
 return function(self, statement, funcDepth)
     local scope = self.activeBlock.scope;
@@ -33,7 +34,11 @@ return function(self, statement, funcDepth)
     local tmpReg = self:allocRegister(false);
     self:addStatement(self:setRegister(scope, tmpReg, Ast.NumberExpression(0)), {tmpReg}, {}, false);
     local incrementIsNegReg = self:allocRegister(false);
-    self:addStatement(self:setRegister(scope, incrementIsNegReg, Ast.LessThanExpression(self:register(scope, incrementReg), self:register(scope, tmpReg))), {incrementIsNegReg}, {incrementReg, tmpReg}, false);
+
+    local shouldSwap3 = math.random(1, 2) == 2;
+    local shuffledRegs4 = shouldSwap3 and {incrementReg, tmpReg} or {tmpReg, incrementReg};
+    self:addStatement(self:setRegister(scope, incrementIsNegReg, Ast[shouldSwap3 and "LessThanExpression" or "GreaterThanExpression"](self:register(scope, shuffledRegs4[1]), self:register(scope, shuffledRegs4[2]))), {incrementIsNegReg}, {shuffledRegs4[1], shuffledRegs4[2]}, false);
+
     self:freeRegister(tmpReg);
 
     local currentReg = self:allocRegister(true);
@@ -45,13 +50,26 @@ return function(self, statement, funcDepth)
     self:setActiveBlock(checkBlock);
 
     scope = checkBlock.scope;
-    self:addStatement(self:setRegister(scope, currentReg, Ast.AddExpression(self:register(scope, currentReg), self:register(scope, incrementReg))), {currentReg}, {currentReg, incrementReg}, false);
+
+    -- x = x + y or x = y + x instead of just x = x + y.
+    --> NEW: In an attempt to thwart deobfuscations, despite this being a simple comparison... Shuffling these causes problems for decompilers.
+    --> NOTE: This isn't unstable code, I've tested it multiple times.
+
+    local shuffledRegs = util.shuffle({currentReg, incrementReg});
+    self:addStatement(self:setRegister(scope, currentReg, Ast.AddExpression(self:register(scope, shuffledRegs[1]), self:register(scope, shuffledRegs[2]))), {currentReg}, {shuffledRegs[1], shuffledRegs[2]}, false);
     local tmpReg1 = self:allocRegister(false);
     local tmpReg2 = self:allocRegister(false);
     self:addStatement(self:setRegister(scope, tmpReg2, Ast.NotExpression(self:register(scope, incrementIsNegReg))), {tmpReg2}, {incrementIsNegReg}, false);
-    self:addStatement(self:setRegister(scope, tmpReg1, Ast.LessThanOrEqualsExpression(self:register(scope, currentReg), self:register(scope, finalReg))), {tmpReg1}, {currentReg, finalReg}, false);
+
+    local shouldSwap = math.random(1, 2) == 2;
+    local shuffledRegs2 = shouldSwap and {currentReg, finalReg} or {finalReg, currentReg};
+    self:addStatement(self:setRegister(scope, tmpReg1, Ast[shouldSwap and "LessThanOrEqualsExpression" or "GreaterThanOrEqualsExpression"](self:register(scope, shuffledRegs2[1]), self:register(scope, shuffledRegs2[2]))), {tmpReg1}, {shuffledRegs2[1], shuffledRegs2[2]}, false);
     self:addStatement(self:setRegister(scope, tmpReg1, Ast.AndExpression(self:register(scope, tmpReg2), self:register(scope, tmpReg1))), {tmpReg1}, {tmpReg1, tmpReg2}, false);
-    self:addStatement(self:setRegister(scope, tmpReg2, Ast.GreaterThanOrEqualsExpression(self:register(scope, currentReg), self:register(scope, finalReg))), {tmpReg2}, {currentReg, finalReg}, false);
+
+    local shouldSwap2 = math.random(1, 2) == 2;
+    local shuffledRegs3 = shouldSwap2 and {currentReg, finalReg} or {finalReg, currentReg};
+    self:addStatement(self:setRegister(scope, tmpReg2, Ast[shouldSwap2 and "LessThanOrEqualsExpression" or "GreaterThanOrEqualsExpression"](self:register(scope, shuffledRegs3[1]), self:register(scope, shuffledRegs3[2]))), {tmpReg2}, {shuffledRegs3[1], shuffledRegs3[2]}, false);
+
     self:addStatement(self:setRegister(scope, tmpReg2, Ast.AndExpression(self:register(scope, incrementIsNegReg), self:register(scope, tmpReg2))), {tmpReg2}, {tmpReg2, incrementIsNegReg}, false);
     self:addStatement(self:setRegister(scope, tmpReg1, Ast.OrExpression(self:register(scope, tmpReg2), self:register(scope, tmpReg1))), {tmpReg1}, {tmpReg1, tmpReg2}, false);
     self:freeRegister(tmpReg2);

src/prometheus/compiler/statements/while_statement.lua

@@ -18,7 +18,7 @@ return function(self, statement, funcDepth)
     self:addStatement(self:setPos(scope, checkBlock.id), {self.POS_REGISTER}, {}, false);
 
     self:setActiveBlock(checkBlock);
-    local scope = self.activeBlock.scope;
+    scope = self.activeBlock.scope;
     local conditionReg = self:compileExpression(statement.condition, funcDepth, 1)[1];
     self:addStatement(self:setRegister(scope, self.POS_REGISTER, Ast.OrExpression(Ast.AndExpression(self:register(scope, conditionReg), Ast.NumberExpression(innerBlock.id)), Ast.NumberExpression(finalBlock.id))), {self.POS_REGISTER}, {conditionReg}, false);
     self:freeRegister(conditionReg, false);