lua-obfuscator 1.0.0

package/dist/prometheus/src/prometheus/steps/EncryptStrings.lua

@@ -0,0 +1,239 @@
+-- This Script is Part of the Prometheus Obfuscator by Levno_710
+--
+-- EncryptStrings.lua
+--
+-- This Script provides a Simple Obfuscation Step that encrypts strings
+
+local Step = require("prometheus.step")
+local Ast = require("prometheus.ast")
+local Scope = require("prometheus.scope")
+local RandomStrings = require("prometheus.randomStrings")
+local Parser = require("prometheus.parser")
+local Enums = require("prometheus.enums")
+local logger = require("logger")
+local visitast = require("prometheus.visitast");
+local util     = require("prometheus.util")
+local AstKind = Ast.AstKind;
+
+local EncryptStrings = Step:extend()
+EncryptStrings.Description = "This Step will encrypt strings within your Program."
+EncryptStrings.Name = "Encrypt Strings"
+
+EncryptStrings.SettingsDescriptor = {}
+
+function EncryptStrings:init(settings) end
+
+
+function EncryptStrings:CreateEncrypionService()
+	local usedSeeds = {};
+
+	local secret_key_6 = math.random(0, 63) -- 6-bit  arbitrary integer (0..63)
+	local secret_key_7 = math.random(0, 127) -- 7-bit  arbitrary integer (0..127)
+	local secret_key_44 = math.random(0, 17592186044415) -- 44-bit arbitrary integer (0..17592186044415)
+	local secret_key_8 = math.random(0, 255); -- 8-bit  arbitrary integer (0..255)
+
+	local floor = math.floor
+
+	local function primitive_root_257(idx)
+		local g, m, d = 1, 128, 2 * idx + 1
+		repeat
+			g, m, d = g * g * (d >= m and 3 or 1) % 257, m / 2, d % m
+		until m < 1
+		return g
+	end
+
+	local param_mul_8 = primitive_root_257(secret_key_7)
+	local param_mul_45 = secret_key_6 * 4 + 1
+	local param_add_45 = secret_key_44 * 2 + 1
+
+	local state_45 = 0
+	local state_8 = 2
+
+	local prev_values = {}
+	local function set_seed(seed_53)
+		state_45 = seed_53 % 35184372088832
+		state_8 = seed_53 % 255 + 2
+		prev_values = {}
+	end
+
+	local function gen_seed()
+		local seed;
+		repeat
+			seed = math.random(0, 35184372088832);
+		until not usedSeeds[seed];
+		usedSeeds[seed] = true;
+		return seed;
+	end
+
+	local function get_random_32()
+		state_45 = (state_45 * param_mul_45 + param_add_45) % 35184372088832
+		repeat
+			state_8 = state_8 * param_mul_8 % 257
+		until state_8 ~= 1
+		local r = state_8 % 32
+		local n = floor(state_45 / 2 ^ (13 - (state_8 - r) / 32)) % 2 ^ 32 / 2 ^ r
+		return floor(n % 1 * 2 ^ 32) + floor(n)
+	end
+
+	local function get_next_pseudo_random_byte()
+		if #prev_values == 0 then
+			local rnd = get_random_32() -- value 0..4294967295
+			local low_16 = rnd % 65536
+			local high_16 = (rnd - low_16) / 65536
+			local b1 = low_16 % 256
+			local b2 = (low_16 - b1) / 256
+			local b3 = high_16 % 256
+			local b4 = (high_16 - b3) / 256
+			prev_values = { b1, b2, b3, b4 }
+		end
+		--print(unpack(prev_values))
+		return table.remove(prev_values)
+	end
+
+	local function encrypt(str)
+		local seed = gen_seed();
+		set_seed(seed)
+		local len = string.len(str)
+		local out = {}
+		local prevVal = secret_key_8;
+		for i = 1, len do
+			local byte = string.byte(str, i);
+			out[i] = string.char((byte - (get_next_pseudo_random_byte() + prevVal)) % 256);
+			prevVal = byte;
+		end
+		return table.concat(out), seed;
+	end
+
+    local function genCode()
+        local code = [[
+do
+	local floor = math.floor
+	local random = math.random;
+	local remove = table.remove;
+	local char = string.char;
+	local state_45 = 0
+	local state_8 = 2
+	local digits = {}
+	local charmap = {};
+	local i = 0;
+
+	local nums = {};
+	for i = 1, 256 do
+		nums[i] = i;
+	end
+
+	repeat
+		local idx = random(1, #nums);
+		local n = remove(nums, idx);
+		charmap[n] = char(n - 1);
+	until #nums == 0;
+
+	local prev_values = {}
+	local function get_next_pseudo_random_byte()
+		if #prev_values == 0 then
+			state_45 = (state_45 * ]] .. tostring(param_mul_45) .. [[ + ]] .. tostring(param_add_45) .. [[) % 35184372088832
+			repeat
+				state_8 = state_8 * ]] .. tostring(param_mul_8) .. [[ % 257
+			until state_8 ~= 1
+			local r = state_8 % 32
+			local n = floor(state_45 / 2 ^ (13 - (state_8 - r) / 32)) % 2 ^ 32 / 2 ^ r
+			local rnd = floor(n % 1 * 2 ^ 32) + floor(n)
+			local low_16 = rnd % 65536
+			local high_16 = (rnd - low_16) / 65536
+			local b1 = low_16 % 256
+			local b2 = (low_16 - b1) / 256
+			local b3 = high_16 % 256
+			local b4 = (high_16 - b3) / 256
+			prev_values = { b1, b2, b3, b4 }
+		end
+		return table.remove(prev_values)
+	end
+
+	local realStrings = {};
+	STRINGS = setmetatable({}, {
+		__index = realStrings;
+		__metatable = nil;
+	});
+  	function DECRYPT(str, seed)
+		local realStringsLocal = realStrings;
+		if(realStringsLocal[seed]) then else
+			prev_values = {};
+			local chars = charmap;
+			state_45 = seed % 35184372088832
+			state_8 = seed % 255 + 2
+			local len = string.len(str);
+			realStringsLocal[seed] = "";
+			local prevVal = ]] .. tostring(secret_key_8) .. [[;
+			for i=1, len do
+				prevVal = (string.byte(str, i) + get_next_pseudo_random_byte() + prevVal) % 256
+				realStringsLocal[seed] = realStringsLocal[seed] .. chars[prevVal + 1];
+			end
+		end
+		return seed;
+	end
+end]]
+
+		return code;
+    end
+
+    return {
+        encrypt = encrypt,
+        param_mul_45 = param_mul_45,
+        param_mul_8 = param_mul_8,
+        param_add_45 = param_add_45,
+		secret_key_8 = secret_key_8,
+        genCode = genCode,
+    }
+end
+
+function EncryptStrings:apply(ast, pipeline)
+    local Encryptor = self:CreateEncrypionService();
+
+	local code = Encryptor.genCode();
+	local newAst = Parser:new({ LuaVersion = Enums.LuaVersion.Lua51 }):parse(code);
+	local doStat = newAst.body.statements[1];
+
+	local scope = ast.body.scope;
+	local decryptVar = scope:addVariable();
+	local stringsVar = scope:addVariable();
+	
+	doStat.body.scope:setParent(ast.body.scope);
+
+	visitast(newAst, nil, function(node, data)
+		if(node.kind == AstKind.FunctionDeclaration) then
+			if(node.scope:getVariableName(node.id) == "DECRYPT") then
+				data.scope:removeReferenceToHigherScope(node.scope, node.id);
+				data.scope:addReferenceToHigherScope(scope, decryptVar);
+				node.scope = scope;
+				node.id    = decryptVar;
+			end
+		end
+		if(node.kind == AstKind.AssignmentVariable or node.kind == AstKind.VariableExpression) then
+			if(node.scope:getVariableName(node.id) == "STRINGS") then
+				data.scope:removeReferenceToHigherScope(node.scope, node.id);
+				data.scope:addReferenceToHigherScope(scope, stringsVar);
+				node.scope = scope;
+				node.id    = stringsVar;
+			end
+		end
+	end)
+
+	visitast(ast, nil, function(node, data)
+		if(node.kind == AstKind.StringExpression) then
+			data.scope:addReferenceToHigherScope(scope, stringsVar);
+			data.scope:addReferenceToHigherScope(scope, decryptVar);
+			local encrypted, seed = Encryptor.encrypt(node.value);
+			return Ast.IndexExpression(Ast.VariableExpression(scope, stringsVar), Ast.FunctionCallExpression(Ast.VariableExpression(scope, decryptVar), {
+				Ast.StringExpression(encrypted), Ast.NumberExpression(seed),
+			}));
+		end
+	end)
+
+
+	-- Insert to Main Ast
+	table.insert(ast.body.statements, 1, doStat);
+	table.insert(ast.body.statements, 1, Ast.LocalVariableDeclaration(scope, util.shuffle{ decryptVar, stringsVar }, {}));
+	return ast
+end
+
+return EncryptStrings

package/dist/prometheus/src/prometheus/steps/NumbersToExpressions.lua

@@ -0,0 +1,82 @@
+-- This Script is Part of the Prometheus Obfuscator by Levno_710
+--
+-- NumbersToExpressions.lua
+--
+-- This Script provides an Obfuscation Step, that converts Number Literals to expressions
+unpack = unpack or table.unpack;
+
+local Step = require("prometheus.step");
+local Ast = require("prometheus.ast");
+local Scope = require("prometheus.scope");
+local visitast = require("prometheus.visitast");
+local util     = require("prometheus.util")
+
+local AstKind = Ast.AstKind;
+
+local NumbersToExpressions = Step:extend();
+NumbersToExpressions.Description = "This Step Converts number Literals to Expressions";
+NumbersToExpressions.Name = "Numbers To Expressions";
+
+NumbersToExpressions.SettingsDescriptor = {
+	Treshold = {
+        type = "number",
+        default = 1,
+        min = 0,
+        max = 1,
+    },
+    InternalTreshold = {
+        type = "number",
+        default = 0.2,
+        min = 0,
+        max = 0.8,
+    }
+}
+
+function NumbersToExpressions:init(settings)
+	self.ExpressionGenerators = {
+        function(val, depth) -- Addition
+            local val2 = math.random(-2^20, 2^20);
+            local diff = val - val2;
+            if tonumber(tostring(diff)) + tonumber(tostring(val2)) ~= val then
+                return false;
+            end
+            return Ast.AddExpression(self:CreateNumberExpression(val2, depth), self:CreateNumberExpression(diff, depth), false);
+        end, 
+        function(val, depth) -- Subtraction
+            local val2 = math.random(-2^20, 2^20);
+            local diff = val + val2;
+            if tonumber(tostring(diff)) - tonumber(tostring(val2)) ~= val then
+                return false;
+            end
+            return Ast.SubExpression(self:CreateNumberExpression(diff, depth), self:CreateNumberExpression(val2, depth), false);
+        end
+    }
+end
+
+function NumbersToExpressions:CreateNumberExpression(val, depth)
+    if depth > 0 and math.random() >= self.InternalTreshold or depth > 15 then
+        return Ast.NumberExpression(val)
+    end
+
+    local generators = util.shuffle({unpack(self.ExpressionGenerators)});
+    for i, generator in ipairs(generators) do
+        local node = generator(val, depth + 1);
+        if node then
+            return node;
+        end
+    end
+
+    return Ast.NumberExpression(val)
+end
+
+function NumbersToExpressions:apply(ast)
+	visitast(ast, nil, function(node, data)
+        if node.kind == AstKind.NumberExpression then
+            if math.random() <= self.Treshold then
+                return self:CreateNumberExpression(node.value, 0);
+            end
+        end
+    end)
+end
+
+return NumbersToExpressions;

package/dist/prometheus/src/prometheus/steps/ProxifyLocals.lua

@@ -0,0 +1,313 @@
+-- This Script is Part of the Prometheus Obfuscator by Levno_710
+--
+-- ProxifyLocals.lua
+--
+-- This Script provides a Obfuscation Step for putting all Locals into Proxy Objects
+
+local Step = require("prometheus.step");
+local Ast = require("prometheus.ast");
+local Scope = require("prometheus.scope");
+local visitast = require("prometheus.visitast");
+local RandomLiterals = require("prometheus.randomLiterals")
+
+local AstKind = Ast.AstKind;
+
+local ProifyLocals = Step:extend();
+ProifyLocals.Description = "This Step wraps all locals into Proxy Objects";
+ProifyLocals.Name = "Proxify Locals";
+
+ProifyLocals.SettingsDescriptor = {
+	LiteralType = {
+		name = "LiteralType",
+		description = "The type of the randomly generated literals",
+		type = "enum",
+		values = {
+			"dictionary",
+			"number",
+			"string",
+            "any",
+		},
+		default = "string",
+	},
+}
+
+local function shallowcopy(orig)
+    local orig_type = type(orig)
+    local copy
+    if orig_type == 'table' then
+        copy = {}
+        for orig_key, orig_value in pairs(orig) do
+            copy[orig_key] = orig_value
+        end
+    else -- number, string, boolean, etc
+        copy = orig
+    end
+    return copy
+end
+
+local function callNameGenerator(generatorFunction, ...)
+	if(type(generatorFunction) == "table") then
+		generatorFunction = generatorFunction.generateName;
+	end
+	return generatorFunction(...);
+end
+
+local MetatableExpressions = {
+    {
+        constructor = Ast.AddExpression,
+        key = "__add";
+    },
+    {
+        constructor = Ast.SubExpression,
+        key = "__sub";
+    },
+    {
+        constructor = Ast.IndexExpression,
+        key = "__index";
+    },
+    {
+        constructor = Ast.MulExpression,
+        key = "__mul";
+    },
+    {
+        constructor = Ast.DivExpression,
+        key = "__div";
+    },
+    {
+        constructor = Ast.PowExpression,
+        key = "__pow";
+    },
+    {
+        constructor = Ast.StrCatExpression,
+        key = "__concat";
+    }
+}
+
+function ProifyLocals:init(settings)
+	
+end
+
+local function generateLocalMetatableInfo(pipeline)
+    local usedOps = {};
+    local info = {};
+    for i, v in ipairs({"setValue","getValue", "index"}) do
+        local rop;
+        repeat
+            rop = MetatableExpressions[math.random(#MetatableExpressions)];
+        until not usedOps[rop];
+        usedOps[rop] = true;
+        info[v] = rop;
+    end
+
+    info.valueName = callNameGenerator(pipeline.namegenerator, math.random(1, 4096));
+
+    return info;
+end
+
+function ProifyLocals:CreateAssignmentExpression(info, expr, parentScope)
+    local metatableVals = {};
+
+    -- Setvalue Entry
+    local setValueFunctionScope = Scope:new(parentScope);
+    local setValueSelf = setValueFunctionScope:addVariable();
+    local setValueArg = setValueFunctionScope:addVariable();
+    local setvalueFunctionLiteral = Ast.FunctionLiteralExpression(
+        {
+            Ast.VariableExpression(setValueFunctionScope, setValueSelf), -- Argument 1
+            Ast.VariableExpression(setValueFunctionScope, setValueArg), -- Argument 2
+        },
+        Ast.Block({ -- Create Function Body
+            Ast.AssignmentStatement({
+                Ast.AssignmentIndexing(Ast.VariableExpression(setValueFunctionScope, setValueSelf), Ast.StringExpression(info.valueName));
+            }, {
+                Ast.VariableExpression(setValueFunctionScope, setValueArg)
+            })
+        }, setValueFunctionScope)
+    );
+    table.insert(metatableVals, Ast.KeyedTableEntry(Ast.StringExpression(info.setValue.key), setvalueFunctionLiteral));
+
+    -- Getvalue Entry
+    local getValueFunctionScope = Scope:new(parentScope);
+    local getValueSelf = getValueFunctionScope:addVariable();
+    local getValueArg = getValueFunctionScope:addVariable();
+    local getValueIdxExpr;
+    if(info.getValue.key == "__index" or info.setValue.key == "__index") then
+        getValueIdxExpr = Ast.FunctionCallExpression(Ast.VariableExpression(getValueFunctionScope:resolveGlobal("rawget")), {
+            Ast.VariableExpression(getValueFunctionScope, getValueSelf),
+            Ast.StringExpression(info.valueName),
+        });
+    else
+        getValueIdxExpr = Ast.IndexExpression(Ast.VariableExpression(getValueFunctionScope, getValueSelf), Ast.StringExpression(info.valueName));
+    end
+    local getvalueFunctionLiteral = Ast.FunctionLiteralExpression(
+        {
+            Ast.VariableExpression(getValueFunctionScope, getValueSelf), -- Argument 1
+            Ast.VariableExpression(getValueFunctionScope, getValueArg), -- Argument 2
+        },
+        Ast.Block({ -- Create Function Body
+            Ast.ReturnStatement({
+                getValueIdxExpr;
+            });
+        }, getValueFunctionScope)
+    );
+    table.insert(metatableVals, Ast.KeyedTableEntry(Ast.StringExpression(info.getValue.key), getvalueFunctionLiteral));
+
+    parentScope:addReferenceToHigherScope(self.setMetatableVarScope, self.setMetatableVarId);
+    return Ast.FunctionCallExpression(
+        Ast.VariableExpression(self.setMetatableVarScope, self.setMetatableVarId),
+        {
+            Ast.TableConstructorExpression({
+                Ast.KeyedTableEntry(Ast.StringExpression(info.valueName), expr)
+            }),
+            Ast.TableConstructorExpression(metatableVals)
+        }
+    );
+end
+
+function ProifyLocals:apply(ast, pipeline)
+    local localMetatableInfos = {};
+    local function getLocalMetatableInfo(scope, id)
+        -- Global Variables should not be transformed
+        if(scope.isGlobal) then return nil end;
+
+        localMetatableInfos[scope] = localMetatableInfos[scope] or {};
+        if localMetatableInfos[scope][id] then
+            -- If locked, return no Metatable
+            if localMetatableInfos[scope][id].locked then
+                return nil
+            end
+            return localMetatableInfos[scope][id];
+        end
+        local localMetatableInfo = generateLocalMetatableInfo(pipeline);
+        localMetatableInfos[scope][id] = localMetatableInfo;
+        return localMetatableInfo;
+    end
+
+    local function disableMetatableInfo(scope, id)
+        -- Global Variables should not be transformed
+        if(scope.isGlobal) then return nil end;
+
+        localMetatableInfos[scope] = localMetatableInfos[scope] or {};
+        localMetatableInfos[scope][id] = {locked = true}
+    end
+
+    -- Create Setmetatable Variable
+    self.setMetatableVarScope = ast.body.scope;
+    self.setMetatableVarId    = ast.body.scope:addVariable();
+
+    -- Create Empty Function Variable
+    self.emptyFunctionScope   = ast.body.scope;
+    self.emptyFunctionId      = ast.body.scope:addVariable();
+    self.emptyFunctionUsed    = false;
+
+    -- Add Empty Function Declaration
+    table.insert(ast.body.statements, 1, Ast.LocalVariableDeclaration(self.emptyFunctionScope, {self.emptyFunctionId}, {
+        Ast.FunctionLiteralExpression({}, Ast.Block({}, Scope:new(ast.body.scope)));
+    }));
+
+
+    visitast(ast, function(node, data)
+        -- Lock for loop variables
+        if(node.kind == AstKind.ForStatement) then
+            disableMetatableInfo(node.scope, node.id)
+        end
+        if(node.kind == AstKind.ForInStatement) then
+            for i, id in ipairs(node.ids) do
+                disableMetatableInfo(node.scope, id);
+            end
+        end
+
+        -- Lock Function Arguments
+        if(node.kind == AstKind.FunctionDeclaration or node.kind == AstKind.LocalFunctionDeclaration or node.kind == AstKind.FunctionLiteralExpression) then
+            for i, expr in ipairs(node.args) do
+                if expr.kind == AstKind.VariableExpression then
+                    disableMetatableInfo(expr.scope, expr.id);
+                end
+            end
+        end
+
+        -- Assignment Statements may be Obfuscated Differently
+        if(node.kind == AstKind.AssignmentStatement) then
+            if(#node.lhs == 1 and node.lhs[1].kind == AstKind.AssignmentVariable) then
+                local variable = node.lhs[1];
+                local localMetatableInfo = getLocalMetatableInfo(variable.scope, variable.id);
+                if localMetatableInfo then
+                    local args = shallowcopy(node.rhs);
+                    local vexp = Ast.VariableExpression(variable.scope, variable.id);
+                    vexp.__ignoreProxifyLocals = true;
+                    args[1] = localMetatableInfo.setValue.constructor(vexp, args[1]);
+                    self.emptyFunctionUsed = true;
+                    data.scope:addReferenceToHigherScope(self.emptyFunctionScope, self.emptyFunctionId);
+                    return Ast.FunctionCallStatement(Ast.VariableExpression(self.emptyFunctionScope, self.emptyFunctionId), args);
+                end
+            end
+        end
+    end, function(node, data)
+        -- Local Variable Declaration
+        if(node.kind == AstKind.LocalVariableDeclaration) then
+            for i, id in ipairs(node.ids) do
+                local expr = node.expressions[i] or Ast.NilExpression();
+                local localMetatableInfo = getLocalMetatableInfo(node.scope, id);
+                -- Apply Only to Some Variables if Treshold is non 1
+                if localMetatableInfo then
+                    local newExpr = self:CreateAssignmentExpression(localMetatableInfo, expr, node.scope);
+                    node.expressions[i] = newExpr;
+                end
+            end
+        end
+
+        -- Variable Expression
+        if(node.kind == AstKind.VariableExpression and not node.__ignoreProxifyLocals) then
+            local localMetatableInfo = getLocalMetatableInfo(node.scope, node.id);
+            -- Apply Only to Some Variables if Treshold is non 1
+            if localMetatableInfo then
+                local literal;
+                if self.LiteralType == "dictionary" then
+                    literal = RandomLiterals.Dictionary();
+                elseif self.LiteralType == "number" then
+                    literal = RandomLiterals.Number();
+                elseif self.LiteralType == "string" then
+                    literal = RandomLiterals.String(pipeline);
+                else
+                    literal = RandomLiterals.Any(pipeline);
+                end
+                return localMetatableInfo.getValue.constructor(node, literal);
+            end
+        end
+
+        -- Assignment Variable for Assignment Statement
+        if(node.kind == AstKind.AssignmentVariable) then
+            local localMetatableInfo = getLocalMetatableInfo(node.scope, node.id);
+            -- Apply Only to Some Variables if Treshold is non 1
+            if localMetatableInfo then
+                return Ast.AssignmentIndexing(node, Ast.StringExpression(localMetatableInfo.valueName));
+            end
+        end
+
+        -- Local Function Declaration
+        if(node.kind == AstKind.LocalFunctionDeclaration) then
+            local localMetatableInfo = getLocalMetatableInfo(node.scope, node.id);
+            -- Apply Only to Some Variables if Treshold is non 1
+            if localMetatableInfo then
+                local funcLiteral = Ast.FunctionLiteralExpression(node.args, node.body);
+                local newExpr = self:CreateAssignmentExpression(localMetatableInfo, funcLiteral, node.scope);
+                return Ast.LocalVariableDeclaration(node.scope, {node.id}, {newExpr});
+            end
+        end
+
+        -- Function Declaration
+        if(node.kind == AstKind.FunctionDeclaration) then
+            local localMetatableInfo = getLocalMetatableInfo(node.scope, node.id);
+            if(localMetatableInfo) then
+                table.insert(node.indices, 1, localMetatableInfo.valueName);
+            end
+        end
+    end)
+
+    -- Add Setmetatable Variable Declaration
+    table.insert(ast.body.statements, 1, Ast.LocalVariableDeclaration(self.setMetatableVarScope, {self.setMetatableVarId}, {
+        Ast.VariableExpression(self.setMetatableVarScope:resolveGlobal("setmetatable"))
+    }));
+end
+
+return ProifyLocals;