lua-obfuscator 1.0.0 → 1.0.1

package/src/prometheus/benchmark.lua

@@ -1,34 +0,0 @@
-print("PROMETHEUS Benchmark")
-print("Based On IronBrew Benchmark")
-local Iterations = 100000
-print("Iterations: " .. tostring(Iterations))
-
-print("CLOSURE testing.")
-local Start = os.clock()
-local TStart = Start
-for Idx = 1, Iterations do
-	(function()
-		if not true then
-			print("Hey gamer.")
-		end
-	end)()
-end
-print("Time:", os.clock() - Start .. "s")
-
-print("SETTABLE testing.")
-Start = os.clock()
-local T = {}
-for Idx = 1, Iterations do
-	T[tostring(Idx)] = "EPIC GAMER " .. tostring(Idx)
-end
-
-print("Time:", os.clock() - Start .. "s")
-
-print("GETTABLE testing.")
-Start = os.clock()
-for Idx = 1, Iterations do
-	T[1] = T[tostring(Idx)]
-end
-
-print("Time:", os.clock() - Start .. "s")
-print("Total Time:", os.clock() - TStart .. "s")

package/src/prometheus/build.bat

@@ -1,10 +0,0 @@
-@echo off
-ECHO Building Prometheus ...
-RMDIR /s /q build
-MKDIR build
-glue.exe ./srlua.exe prometheus-main.lua build/prometheus.exe
-robocopy ./src ./build/lua /E>nul
-
-robocopy . ./build lua51.dll>nul
-
-ECHO Done!

package/src/prometheus/cli.lua

@@ -1,12 +0,0 @@
--- This Script is Part of the Prometheus Obfuscator by Levno_710
---
--- test.lua
--- This script contains the Code for the Prometheus CLI
-
--- Configure package.path for requiring Prometheus
-local function script_path()
-	local str = debug.getinfo(2, "S").source:sub(2)
-	return str:match("(.*[/%\\])") or "";
-end
-package.path = script_path() .. "?.lua;" .. package.path;
-require("src.cli");

package/src/prometheus/doc/README.md

@@ -1,11 +0,0 @@
----
-description: Prometheus is an Lua Obfuscator, that is written in pure Lua.
----
-
-# Prometheus
-
-Prometheus can obfuscate Lua51 as well as Roblox's LuaU, which is an optionally typed superset of Lua51.
-
-View Prometheus on [github](https://github.com/levno-710/Prometheus).
-
-This Documentation only applies to the newest version of Prometheus.

package/src/prometheus/doc/SUMMARY.md

@@ -1,27 +0,0 @@
-# Table of contents
-
-* [Prometheus](README.md)
-
-## Getting Started
-
-* [Installation](getting-started/installation.md)
-* [Obfuscating your first script](getting-started/obfuscating-your-first-script.md)
-* [Command Line Options](getting-started/command-line-options.md)
-* [Presets](getting-started/presets.md)
-* [Writing a custom Config File](getting-started/writing-a-custom-config-file.md)
-* [The Config Object](getting-started/the-config-object.md)
-
-## Steps
-
-* [WrapInFunction](steps/wrapinfunction.md)
-* [Vmify](steps/vmify.md)
-* [SplitStrings](steps/splitstrings.md)
-* [ProxifyLocals](steps/proxifylocals.md)
-* [EncryptStrings](steps/encryptstrings.md)
-* [ConstantArray](steps/constantarray.md)
-* [AntiTamper](steps/anti-tamper.md)
-
-
-## advanced
-
-* [Using Prometheus in your Lua Application](advanced/using-prometheus-in-your-lua-application.md)

package/src/prometheus/doc/advanced/using-prometheus-in-your-lua-application.md

@@ -1,31 +0,0 @@
-# Using Prometheus in your Lua Application
-
-Prometheus can also be used as a library for your custom Lua Applications instead of using its cli tool. 
-
-In order to do that you'll first need to clone the github repo:
-
-```batch
-git clone "https://github.com/levno-710/Prometheus.git"
-```
-
-After that, you'll need to copy everything within the src folder to your project. Let's say you created a folder named `prometheus`, where all the Prometheus files are located. You can the use the following code to obfuscate a string:
-
-{% code title="use_prometheus.lua" %}
-```lua
-local Prometheus = require("prometheus.prometheus")
-
--- If you don't want console output
-Prometheus.Logger.logLevel = Prometheus.Logger.LogLevel.Error
-
--- Your code
-local code = 'print("Hello, World!")'
-
--- Create a Pipeline using the Strong preset
-local pipeline = Prometheus.Pipeline:fromConfig(Prometheus.Presets.Strong)
-
--- Apply the obfuscation and print the result
-print(pipeline:apply(code));
-```
-{% endcode %}
-
-Instead of passing the Strong preset you could also pass a custom [Config Object](../getting-started/the-config-object.md).

package/src/prometheus/doc/getting-started/command-line-options.md

@@ -1,13 +0,0 @@
-# Command Line Options
-
-The following table provides a brief overview over the command line options:
-
-| Option                        | Usage                                                       |
-| ----------------------------- | ----------------------------------------------------------- |
-| --preset \[name]; --p \[name] | Specify the config preset to be used; [Details](presets.md) |
-| --config \[path]; --c \[path] | Specify the path to a custom config file                    |
-| --out \[path]; --o \[path]    | Specify the path of the output file                         |
-| --nocolors                    | Disable ansi colors escape sequences                        |
-| --Lua51                       | Handle input as Lua 5.1                                     |
-| --LuaU                        | Handle input as LuaU                                        |
-| --pretty                      | Pretty print the output                                     |

package/src/prometheus/doc/getting-started/installation.md

@@ -1,11 +0,0 @@
-# Installation
-
-To install Prometheus, simply clone the Github Repository using:
-
-```batch
-git clone "https://github.com/levno-710/Prometheus.git"
-```
-
-Alternatively you can download the Sources [here](https://github.com/levno-710/Prometheus/archive/refs/heads/master.zip).
-
-Prometheus also Requires LuaJIT or Lua51 in order to work. The Lua51 binaries can be downloaded [here](https://sourceforge.net/projects/luabinaries/files/5.1.5/Tools%20Executables/).

package/src/prometheus/doc/getting-started/obfuscating-your-first-script.md

@@ -1,50 +0,0 @@
-# Obfuscating your first script
-
-Now that you have downloaded and Prometheus, you probably wonder how to use it. In this quick tutorial you are going to learn how to obfuscate your first file.
-
-Note that in the following command examples `lua` should be replaced by your lua implementation.
-
-Create the following file within the Prometheus main directory that you just downloaded:
-
-{% code title="hello_world.lua" %}
-```lua
-print("Hello, World")
-```
-{% endcode %}
-
-Now run the following command inside of the Prometheus directory:
-
-```batch
-lua ./cli.lua ./hello_world.lua
-```
-
-You may notice, that the console output looks weird. If that is the case, your terminal does not support ansi color escape sequences. You should add the `--nocolors` option:
-
-```batch
-lua ./cli.lua --nocolors ./hello_world.lua
-```
-
-This should create the following file:
-
-{% code title="hello_world.obfuscated.lua" %}
-```lua
-print("Hello, World")
-```
-{% endcode %}
-
-As you can see, the file hasn't changed at all. That is because by default prometheus is just a minifier and the code we gave it was already as small as possible. To actually obfuscate the file, prometheus must be told which obfuscation steps it should apply in which order. In order to do this, the cli provides the `--preset` option which allows you to specify the name of a predefined configuration. There are currently the following presets:
-
-* Minify
-* Weak
-* Medium
-* Strong
-
-In order to perform the obfuscation, you need to specify that Prometheus should use the Strong preset:
-
-```batch
-lua ./cli.lua --preset Medium ./hello_world.lua
-```
-
-The `hello_world.obfuscated.lua` should now contain the obfuscated code that should still print "Hello World".
-
-Note that using the "Strong" preset is not recommended for large projects.

package/src/prometheus/doc/getting-started/presets.md

@@ -1,10 +0,0 @@
-# Presets
-
-The following table provides an overview over the presets
-
-| name   | size   | speed   |
-| ------ | ------ | ------- |
-| Minify | tiny   | fastest |
-| Weak   | small  | fast    |
-| Medium | medium | medium  |
-| Strong | huge   | slowest |

package/src/prometheus/doc/getting-started/the-config-object.md

@@ -1,58 +0,0 @@
-# The Config Object
-
-Prometheus takes a configuration objetct. In this object there can be many properties applied.   \
-The following table provides an overview:
-
-| Property      | type    | possible values                              | default           |
-| ------------- | ------- | -------------------------------------------- | ----------------- |
-| LuaVersion    | string  | "Lua51", "LuaU"                              | "Lua51"           |
-| PrettyPrint   | boolean | true, false                                  | false             |
-| VarNamePrefix | string  | any                                          | ""                |
-| NameGenerator | string  | "Mangled", "MangledShuffled", "Il", "Number" | "MangledShuffled" |
-| Seed          | number  | any                                          | 0                 |
-| Steps         | table   | StepConfig\[]                                | {}                |
-
-As this table shows, all properties in the config object are optional as they have a default value.
-
-As an example, here is the code for the minify preset:
-
-```lua
-{
-        -- The default LuaVersion is Lua51
-        LuaVersion = "Lua51";
-        -- For minifying no VarNamePrefix is applied
-        VarNamePrefix = "";
-        -- Name Generator for Variables
-        NameGenerator = "MangledShuffled";
-        -- No pretty printing
-        PrettyPrint = false;
-        -- Seed is generated based on current time
-        Seed = 0;
-        -- No obfuscation steps
-        Steps = {
-        
-        }
-    };
-```
-
-### Steps
-
-The most important property is the Steps property. This property must be a table of so called Step Configs. A Step in Prometheus describes a single transformation applied to your script by the Prometheus obfuscation pipeline. A StepConfiguration consists of the Name of the Step as well as settings for the step. All Steps will later be applied in the order they are defined. A single Step can be defined twice and will then be applied twice.
-
-```lua
--- Obfuscation steps
-Steps = {
-    {
-        -- This obfuscation step puts all constants into an array at the beginning of the code
-        Name = "ConstantArray";
-        Settings = {
-            -- Apply to Strings only
-            StringsOnly = true;
-            -- Apply to all Constants, 0.5 would only affect 50% of strings
-            Treshold    = 1;
-        }
-    },
-}
-```
-
-Under [Steps](broken-reference), you can find all current Steps, their names as well as the possible options.

package/src/prometheus/doc/getting-started/writing-a-custom-config-file.md

@@ -1,56 +0,0 @@
-# Writing a custom Config File
-
-Configuration Files for Prometheus are just lua modules, that return a single object, which contains the configuration. Let's say we have the following config file:
-
-{% code title="config.lua" %}
-```lua
-return {
-        -- The default LuaVersion is Lua51
-        LuaVersion = "Lua51"; -- or "LuaU"
-        -- All Variables will start with this prefix
-        VarNamePrefix = "";
-        -- Name Generator for Variables that look like this: b, a, c, D, t, G
-        NameGenerator = "MangledShuffled";
-        -- No pretty printing
-        PrettyPrint = false;
-        -- Seed is generated based on current time 
-        -- When specifying a seed that is not 0, you will get the same output every time
-        Seed = 0;
-        -- Obfuscation steps
-        Steps = {
-            {
-                -- This obfuscation step puts all constants into an array at the beginning of the code
-                Name = "ConstantArray";
-                Settings = {
-                    -- Apply to Strings only
-                    StringsOnly = true;
-                    -- Apply to all Constants, 0.5 would only affect 50% of strings
-                    Treshold    = 1;
-                }
-            },
-        }
-    }
-```
-{% endcode %}
-
-One can now obfuscate a script using this configuration by running:
-
-```batch
-lua ./cli.lua --config config.lua hello_world.lua
-```
-
-You should get the following output:
-
-{% code title="hello_world.obfuscated.lua" %}
-```lua
-local N={"Hello, World!"}local function k(k)return N[k+40058]end print(k(-40057))
-```
-{% endcode %}
-
-As you can see, the only transformation that was applied to our Hello World example was putting all strings (in this case only `"Hello, World!"` ) into an array and creating a wrapper function for retrieving the value.
-
-### How does the Config File work?
-
-The config file is simply a lua file, that returns the configuration object. Please note that this lua file is sandboxed by Prometheus when loading the configuration, meaning that you can't use any predefined functions like `tostring` or libraries like `math`.
-
-See [The Config Object](the-config-object.md) to learn what this configuration object consists of.

package/src/prometheus/doc/steps/anti-tamper.md

@@ -1,11 +0,0 @@
----
-description: This step provides an obfuscation step, that breaks the script, when someone tries to tamper with it.
----
-
-# Anti Tamper
-
-### Settings
-
-| Name        | type | description                                 | values                                  |
-| ----------- | ---- | ------------------------------------------- | --------------------------------------- |
-| UseDebug | boolean | Uses the debug library in lua. Disable this if you don't have access to debug library | "true","false" |

package/src/prometheus/doc/steps/constantarray.md

@@ -1,71 +0,0 @@
----
-description: >-
-  This Step will Extract all Constants and put them into an Array at the
-  beginning of the script
----
-
-# ConstantArray
-
-### Settings
-
-| Name                 | type    | description                                                                                                  |
-| -------------------- | ------- | ------------------------------------------------------------------------------------------------------------ |
-| Treshold             | number  | The relative amount of nodes that will be affected"                                                          |
-| StringsOnly          | boolean | Wether to only Extract Strings                                                                               |
-| Shuffle              | boolean | Wether to shuffle the order of Elements in the Array                                                         |
-| Rotate               | boolean | Wether to rotate the String Array by a specific (random) amount. This will be undone on runtime.             |
-| LocalWrapperTreshold | number  | The relative amount of nodes functions, that will get local wrappers                                         |
-| LocalWrapperCount    | number  | The number of Local wrapper Functions per scope. This only applies if LocalWrapperTreshold is greater than 0 |
-| LocalWrapperArgCount | number  | The number of Arguments to the Local wrapper Functions                                                       |
-| MaxWrapperOffset     | number  | The Max Offset for the Wrapper Functions                                                                     |
-
-### Example
-
-{% code title="in.lua" %}
-```lua
-print("1")
-print("2")
-print("3")
-print("4")
-```
-{% endcode %}
-
-{% code title="out.lua" %}
-```lua
--- LocalWrapperCount    = 3
--- LocalWrapperArgCount = 5
-local F = {"4", "3", "2", "1"}
-do
-    local y, G = 1, 4
-    while y < G do
-        F[y], F[G] = F[G], F[y]
-        y, G = y + 1, G - 1
-    end
-    y, G = 1, 3
-    while y < G do
-        F[y], F[G] = F[G], F[y]
-        y, G = y + 1, G - 1
-    end
-    y, G = 4, 4
-    while y < G do
-        F[y], F[G] = F[G], F[y]
-        y, G = y + 1, G - 1
-    end
-end
-local function y(y)
-    return F[y + 440]
-end
-local G = {cb = function(F, G, R, p, b)
-        return y(G - 2277)
-    end, n = function(F, G, R, p, b)
-        return y(p + 47178)
-    end, B = function(F, G, R, p, b)
-        return y(F + 31775)
-    end}
-print(G.cb(1575, 1840, 2367, 1293, 1280))
-print(G.B(-32213, -31781, -31538, -32780, -32728))
-print(G.B(-32214, -33004, -31973, -32125, -31855))
-print(G.B(-32211, -31884, -31217, -32222, -31210))
-
-```
-{% endcode %}

package/src/prometheus/doc/steps/encryptstrings.md

@@ -1,86 +0,0 @@
----
-description: This Step will encrypt all String constants in your code
----
-
-# EncryptStrings
-
-## Settings
-
-None
-
-## Example
-
-{% code title="in.lua" %}
-```lua
-print("Hello, World!")
-```
-{% endcode %}
-
-{% code title="out.lua" %}
-```lua
--- Settings: None
-local x, F
-do
-    local k = math.floor
-    local I = math.random
-    local Y = table.remove
-    local i = string.char
-    local K = 0
-    local J = 2
-    local Q = {}
-    local W = {}
-    local q = 0
-    local R = {}
-    for F = 1, 256, 1 do
-        R[F] = F
-    end
-    repeat
-        local F = I(1, #R)
-        local x = Y(R, F)
-        W[x] = i(x - 1)
-    until #R == 0
-    local j = {}
-    local function B()
-        if #j == 0 then
-            K = (K * 173 + 8408159861491) % 35184372088832
-            repeat
-                J = (J * 160) % 257
-            until J ~= 1
-            local F = J % 32
-            local x = (k(K / 2 ^ (13 - (J - F) / 32)) % 4294967296) / 2 ^ F
-            local I = k((x % 1) * 4294967296) + k(x)
-            local Y = I % 65536
-            local i = (I - Y) / 65536
-            local Q = Y % 256
-            local W = (Y - Q) / 256
-            local q = i % 256
-            local R = (i - q) / 256
-            j = {Q, W, q, R}
-        end
-        return table.remove(j)
-    end
-    local d = {}
-    x = setmetatable({}, {__index = d, __metatable = nil})
-    function F(x, k)
-        local I = d
-        if I[k] then
-        else
-            j = {}
-            local F = W
-            K = k % 35184372088832
-            J = k % 255 + 2
-            local Y = string.len(x)
-            I[k] = ""
-            local i = 198
-            for Y = 1, Y, 1 do
-                i = ((string.byte(x, Y) + B()) + i) % 256
-                I[k] = I[k] .. F[i + 1]
-            end
-        end
-        return k
-    end
-end
-print(x[F("\219\018Q%~Y\225\128u\128\208&\155", 6909832146399)])
-
-```
-{% endcode %}

package/src/prometheus/doc/steps/proxifylocals.md

@@ -1,47 +0,0 @@
----
-description: This Step wraps all locals into Proxy Objects
----
-
-# ProxifyLocals
-
-### Settings
-
-| Name        | type | description                                 | values                                  |
-| ----------- | ---- | ------------------------------------------- | --------------------------------------- |
-| LiteralType | enum | The type of the randomly generated literals | "dictionary", "number", "string", "any" |
-
-### Example
-
-{% code title="in.lua" %}
-```lua
-local x = "Hello, World!"
-print(x)
-```
-{% endcode %}
-
-{% code title="out.lua" %}
-```lua
--- LiteralType = "dictionary"
-local n = setmetatable
-local D =
-    n(
-    {Wz = function()
-        end},
-    {__div = function(R, n)
-            R.Wz = n
-        end, __concat = function(R, n)
-            return R.Wz
-        end}
-)
-local R =
-    n(
-    {Js = "Hello, World!"},
-    {__add = function(R, n)
-            R.Js = n
-        end, __index = function(R, n)
-            return rawget(R, "Js")
-        end}
-)
-print(R.Muirgen)
-```
-{% endcode %}

package/src/prometheus/doc/steps/splitstrings.md

@@ -1,40 +0,0 @@
----
-description: This Step splits Strings to a specific or random length
----
-
-# SplitStrings
-
-### Settings
-
-| Name                      | type   | description                                                                                                                                                                            | Values                      |
-| ------------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |
-| Treshold                  | number | The relative amount of nodes that will be affected                                                                                                                                     | 0 <= x <= 1                 |
-| MinLength                 | number | The minimal length for the chunks in that the Strings are splitted                                                                                                                     | x > 0                       |
-| MaxLength                 | number | The maximal length for the chunks in that the Strings are splitted                                                                                                                     | x >= MinLength              |
-| ConcatenationType         | enum   | The Functions used for Concatenation. Note that when using custom, the String Array will also be Shuffled                                                                              | "strcat", "table", "custom" |
-| CustomFunctionType        | enum   | <p>The Type of Function code injection This Option only applies when custom Concatenation is selected.<br>Note that when chosing inline, the code size may increase significantly!</p> | "global", "local", "inline" |
-| CustomLocalFunctionsCount | number | The number of local functions per scope. This option only applies when CustomFunctionType = local                                                                                      | x > 0                       |
-
-### Example
-
-{% code title="in.lua" %}
-```lua
-print("Hello, World!")
-```
-{% endcode %}
-
-{% code title="out.lua" %}
-```lua
--- MinLength = 1
--- MaxLength = 1
-local f = function(f)
-    local k, C = f[#f], ""
-    for j = 1, #k, 1 do
-        C = C .. k[f[j]]
-    end
-    return C
-end
-print(f({13, 11, 4, 12, 1, 6, 8, 10, 9, 7, 3, 2, 5, {"o", "d", "l", "l", "!", ",", "r", " ", "o", "W", "e", "l", "H"}}))
-
-```
-{% endcode %}

package/src/prometheus/doc/steps/vmify.md

@@ -1,9 +0,0 @@
----
-description: This Step will Compile your script and run it within a Vm
----
-
-# Vmify
-
-### Settings
-
-None

package/src/prometheus/doc/steps/wrapinfunction.md

@@ -1,29 +0,0 @@
----
-description: This Step Wraps the Entire Script into a Function
----
-
-# WrapInFunction
-
-### Settings
-
-| Name       | type   | description              |
-| ---------- | ------ | ------------------------ |
-| Iterations | number | The Number Of Iterations |
-
-### Example
-
-{% code title="in.lua" %}
-```lua
-print("Hello, World!")
-```
-{% endcode %}
-
-{% code title="out.lua" %}
-```lua
--- Iterations = 1
-return (function()
-    print("Hello, World!")
-end)()
-
-```
-{% endcode %}

package/src/prometheus/prometheus-main.lua

@@ -1 +0,0 @@
-require("cli")