From b9ac7cd6b06f444209b97c2e10883640507aba66 Mon Sep 17 00:00:00 2001
From: Flatlogic Bot <support@flatlogic.com>
Date: Sat, 31 Jan 2026 14:06:58 +0000
Subject: [PATCH] 15:06

---
 core/__pycache__/obfuscator.cpython-311.pyc | Bin 14177 -> 24407 bytes
 core/obfuscator.py                          | 236 ++++++++++++--------
 test_supreme.py                             |  21 ++
 3 files changed, 169 insertions(+), 88 deletions(-)
 create mode 100644 test_supreme.py

diff --git a/core/__pycache__/obfuscator.cpython-311.pyc b/core/__pycache__/obfuscator.cpython-311.pyc
index 0bc962adad32e58724492f7ac4ba1323991c47e7..ee394f234c6a6289576d2da3e21ad7d63df19f23 100644
GIT binary patch
literal 24407
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

delta 4936
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

diff --git a/core/obfuscator.py b/core/obfuscator.py
index b7f0d9a..4e842e3 100644
--- a/core/obfuscator.py
+++ b/core/obfuscator.py
@@ -16,15 +16,63 @@ class LuauVMObfuscator:
         ]
         
         # Arithmetic keys for opcode decoding
-        self.k1 = random.randint(50, 200)
-        self.k2 = random.randint(50, 200)
-        self.k3 = random.randint(1, 10) # Multiplier/Step
+        self.k1 = random.randint(100, 500)
+        self.k2 = random.randint(100, 500)
         
         # Opcode to encoded ID: (real_index + k1) ^ k2
-        self.op_to_id = {name: ((self.opcodes.index(name) + self.k1) ^ self.k2) % 256 for name in self.opcodes}
+        self.op_to_id = {name: ((self.opcodes.index(name) + self.k1) ^ self.k2) % 1024 for name in self.opcodes}
+        
+        # Variable Renaming Map
+        self.var_map = {}
+        self.used_vars = set()
+
+    def get_var(self, hint="var"):
+        if hint in self.var_map:
+            return self.var_map[hint]
+        
+        chars = "l1I0O" 
+        new_var = "_" + "".join(random.choice(chars) for _ in range(random.randint(10, 15)))
+        while new_var in self.used_vars:
+            new_var = "_" + "".join(random.choice(chars) for _ in range(random.randint(10, 15)))
+        
+        self.used_vars.add(new_var)
+        self.var_map[hint] = new_var
+        return new_var
+
+    def to_expr(self, n, depth=0):
+        # Recursively build complex expressions
+        if depth > 2 or random.random() < 0.1:
+            return str(n)
+        
+        r = random.randint(1, 1000)
+        choice = random.choice(['add', 'sub', 'xor', 'mul'])
+        
+        if choice == 'add':
+            return f"({self.to_expr(n - r, depth + 1)} + {self.to_expr(r, depth + 1)})"
+        elif choice == 'sub':
+            return f"({self.to_expr(n + r, depth + 1)} - {self.to_expr(r, depth + 1)})"
+        elif choice == 'xor':
+            return f"bit32.bxor({self.to_expr(n ^ r, depth + 1)}, {self.to_expr(r, depth + 1)})"
+        elif choice == 'mul':
+            if n != 0 and n % 2 == 0:
+                return f"({self.to_expr(n // 2, depth + 1)} * {self.to_expr(2, depth + 1)})"
+            return f"({self.to_expr(n, depth + 1)})"
+        
+        return str(n)
+
+    def opaque_predicate(self):
+        v1 = random.randint(100, 1000)
+        v2 = random.randint(100, 1000)
+        preds = [
+            f"({self.to_expr(v1)} == {self.to_expr(v1)})",
+            f"({self.to_expr(v1)} + {self.to_expr(v2)} > {self.to_expr(v1)})",
+            f"(math.floor(math.pi) == {self.to_expr(3)})",
+            f"(string.len('SUPREME') == {self.to_expr(7)})",
+            f"(bit32.bor({v1}, {v1}) == {v1})"
+        ]
+        return random.choice(preds)
 
     def encrypt_string(self, s, key):
-        # More complex XOR scheme: each byte depends on previous byte and index
         res = []
         last = key % 256
         for i, c in enumerate(s):
@@ -35,47 +83,36 @@ class LuauVMObfuscator:
 
     def generate_vm_source(self, bytecode):
         raw_instructions = bytecode['instructions']
-        # Each instruction is [OP, A, B, C]
-        
-        # SHUFFLE AND FLATTEN: 
-        # We will add a 'next' index to each instruction to break linear execution.
-        # Format: [OP, A, B, C, NEXT_IDX_L, NEXT_IDX_H] (6 bytes)
         shuffled = []
         indices = list(range(len(raw_instructions)))
         random.shuffle(indices)
         
-        # Map original index to shuffled index
         pos_map = {orig: shuffled_idx for shuffled_idx, orig in enumerate(indices)}
         
-        # Prepare 6-byte instructions
         final_insts = [None] * len(raw_instructions)
         for i, orig_idx in enumerate(indices):
             inst = raw_instructions[orig_idx]
             
-            # Find next shuffled index
             if orig_idx + 1 < len(raw_instructions):
                 next_orig = orig_idx + 1
                 next_shuffled = pos_map[next_orig]
             else:
-                next_shuffled = 0 # End
+                next_shuffled = 0 
             
-            # Pack: [OP, A, B, C, Next_L, Next_H]
             packed = [
-                inst[0], inst[1], inst[2], inst[3],
+                inst[0] & 0xFF, (inst[0] >> 8) & 0xFF, # OP is now 2 bytes for more range
+                inst[1], inst[2], inst[3],
                 next_shuffled & 0xFF, (next_shuffled >> 8) & 0xFF
             ]
             final_insts[i] = packed
 
-        # Pack instructions into a string
         inst_str = "".join(chr(i) for inst in final_insts for i in inst)
         inst_b64 = base64.b64encode(inst_str.encode('latin-1')).decode()
         
-        # Prepare constants
         encrypted_consts = []
-        salt = random.randint(1000, 9999)
+        salt = random.randint(10000, 99999)
         for i, c in enumerate(bytecode['constants']):
             if c['type'] == 'string':
-                # Encrypt with complex key
                 key = (i * 149 + salt) % 256
                 enc_val = self.encrypt_string(c['value'], key)
                 encrypted_consts.append({"t": 1, "v": base64.b64encode(enc_val.encode('latin-1')).decode()})
@@ -83,19 +120,40 @@ class LuauVMObfuscator:
                 encrypted_consts.append({"t": 2, "v": c['value']})
         
         consts_json = json.dumps(encrypted_consts)
-        
-        # Starting shuffled index
         start_idx = pos_map[0]
 
+        # Obfuscated Variable Names
+        V_ENV = self.get_var("env")
+        V_B64 = self.get_var("b64")
+        V_D = self.get_var("decode")
+        V_INST = self.get_var("inst_raw")
+        V_CONSTS = self.get_var("consts")
+        V_SALT = self.get_var("salt")
+        V_EXEC = self.get_var("execute")
+        V_REGS = self.get_var("registers")
+        V_CURR = self.get_var("current")
+        V_RUN = self.get_var("running")
+        V_GETC = self.get_var("get_const")
+        V_PTR = self.get_var("ptr")
+        V_OP = self.get_var("op")
+        V_A = self.get_var("a")
+        V_B = self.get_var("b")
+        V_C = self.get_var("c")
+        V_BIT = self.get_var("bit32")
+        V_GS = self.get_var("getservice")
+
         vm_lua = f"""
--- [[ LUAU-VM HARDENED - V2 ]]
-local _ENV = getfenv()
-local _B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-local _D = function(data)
-    data = string.gsub(data, '[^'.._B64..'=]', '')
+-- [[ LUAU-VM SUPREME V3 - ROBLOX EXECUTOR EXCLUSIVE ]]
+local {V_ENV} = getfenv()
+local {V_BIT} = bit32
+local {V_GS} = game.GetService
+local {V_B64} = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+local {V_D} = function(data)
+    if not ({self.opaque_predicate()}) then return "" end
+    data = string.gsub(data, '[^'..{V_B64}..'=]', '')
     return (data:gsub('.', function(x)
         if (x == '=') then return '' end
-        local r,f='',(_B64:find(x)-1)
+        local r,f='',({V_B64}:find(x)-1)
         for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
         return r;
     end):gsub('%d%d%d%d%d%d%d%d', function(x)
@@ -105,45 +163,45 @@ local _D = function(data)
     end))
 end
 
--- Anti-Analysis Layer
-local function _CHECK()
-    -- Check for common hooks or debuggers
-    local suspicious = {{ "getgenv", "getrenv", "getreg", "debug" }}
-    for _, s in ipairs(suspicious) do
-        if _ENV[s] then 
-            -- Fake failure or subtle corruption
-            return true 
-        end
-    end
-    return false
+-- Advanced Integrity & Sandbox Detection
+local function _S()
+    local d = {{ "getgenv", "getrenv", "getreg", "debug", "Drawing", "hookfunction" }}
+    local c = 0
+    for _, v in ipairs(d) do if {V_ENV}[v] then c = c + 1 end end
+    if c == 0 and not ({self.opaque_predicate()}) then return false end
+    -- Check for Roblox specific globals
+    if not {V_ENV}["game"] or not {V_ENV}["task"] then return false end
+    return true
 end
 
-local _INST_RAW = _D('{inst_b64}')
-local _CONSTS = game:GetService("HttpService"):JSONDecode('{consts_json}')
-local _SALT = {salt}
+local {V_INST} = {V_D}('{inst_b64}')
+local {V_CONSTS} = {V_GS}(game, "HttpService"):JSONDecode('{consts_json}')
+local {V_SALT} = {self.to_expr(salt)}
 
-local function _EXECUTE()
-    if _CHECK() then
-        -- Insert bogus delay or crash if hooked
-        for i=1, 100000 do local x = math.sin(i) end
+local function {V_EXEC}()
+    if not _S() then 
+        -- Trap: Infinite loop or crash
+        local _trap = function() while true do end end
+        task.spawn(_trap)
+        return
     end
 
-    local registers = {{}}
-    local current = {start_idx}
-    local running = true
+    local {V_REGS} = {{}}
+    local {V_CURR} = {self.to_expr(start_idx)}
+    local {V_RUN} = true
     
-    local function get_const(idx)
-        local c = _CONSTS[idx + 1]
+    local function {V_GETC}(idx)
+        local c = {V_CONSTS}[idx + 1]
         if not c then return nil end
-        if c.t == 1 then
-            local raw = _D(c.v)
-            local key = (idx * 149 + _SALT) % 256
+        if c.t == {self.to_expr(1)} then
+            local raw = {V_D}(c.v)
+            local key = (idx * {self.to_expr(149)} + {V_SALT}) % {self.to_expr(256)}
             local res = ""
             local last = key % 256
             for i=1, #raw do
                 local k = (key + i + last - 1) % 256
                 local b = string.byte(raw, i)
-                local char_code = bit32.bxor(b, k)
+                local char_code = {V_BIT}.bxor(b, k)
                 res = res .. string.char(char_code)
                 last = char_code
             end
@@ -152,49 +210,49 @@ local function _EXECUTE()
         return c.v
     end
 
-    -- MEGA-DISPATCH LOOP (Control-Flow Flattening)
-    while running do
-        local ptr = current * 6 + 1
-        if ptr > #_INST_RAW then break end
+    -- SUPREME DISPATCHER
+    while {V_RUN} do
+        if not ({self.opaque_predicate()}) then break end
+        local {V_PTR} = {V_CURR} * {self.to_expr(7)} + 1
+        if {V_PTR} > #{V_INST} then break end
         
-        local op_raw = string.byte(_INST_RAW, ptr)
-        local a = string.byte(_INST_RAW, ptr + 1)
-        local b = string.byte(_INST_RAW, ptr + 2)
-        local c = string.byte(_INST_RAW, ptr + 3)
-        local next_l = string.byte(_INST_RAW, ptr + 4)
-        local next_h = string.byte(_INST_RAW, ptr + 5)
+        local op_l = string.byte({V_INST}, {V_PTR})
+        local op_h = string.byte({V_INST}, {V_PTR} + 1)
+        local {V_A} = string.byte({V_INST}, {V_PTR} + 2)
+        local {V_B} = string.byte({V_INST}, {V_PTR} + 3)
+        local {V_C} = string.byte({V_INST}, {V_PTR} + 4)
+        local next_l = string.byte({V_INST}, {V_PTR} + 5)
+        local next_h = string.byte({V_INST}, {V_PTR} + 6)
         
-        current = next_l + (next_h * 256)
+        {V_CURR} = next_l + (next_h * {self.to_expr(256)})
         
-        -- Arithmetic Opcode Decoding
-        local op = bit32.bxor(op_raw, {self.k2}) - {self.k1}
+        local op_raw = op_l + (op_h * 256)
+        local {V_OP} = {V_BIT}.bxor(op_raw, {self.to_expr(self.k2)}) - {self.to_expr(self.k1)}
         
-        if op == {self.opcodes.index('MOVE')} then
-            registers[a] = registers[b]
-        elseif op == {self.opcodes.index('LOADK')} then
-            registers[a] = get_const(b)
-        elseif op == {self.opcodes.index('GETGLOBAL')} then
-            registers[a] = _ENV[get_const(b)]
-        elseif op == {self.opcodes.index('SETGLOBAL')} then
-            _ENV[get_const(b)] = registers[a]
-        elseif op == {self.opcodes.index('CALL')} then
-            local f = registers[a]
+        if {V_OP} == {self.to_expr(self.opcodes.index('MOVE'))} then
+            {V_REGS}[{V_A}] = {V_REGS}[{V_B}]
+        elseif {V_OP} == {self.to_expr(self.opcodes.index('LOADK'))} then
+            {V_REGS}[{V_A}] = {V_GETC}({V_B})
+        elseif {V_OP} == {self.to_expr(self.opcodes.index('GETGLOBAL'))} then
+            {V_REGS}[{V_A}] = {V_ENV}[{V_GETC}({V_B})]
+        elseif {V_OP} == {self.to_expr(self.opcodes.index('SETGLOBAL'))} then
+            {V_ENV}[{V_GETC}({V_B})] = {V_REGS}[{V_A}]
+        elseif {V_OP} == {self.to_expr(self.opcodes.index('CALL'))} then
+            local f = {V_REGS}[{V_A}]
             local args = {{}}
-            if b > 1 then for i=1, b-1 do args[i] = registers[a+i] end end
+            if {V_B} > 1 then for i=1, {V_B}-1 do args[i] = {V_REGS}[{V_A}+i] end end
             local res = {{f(unpack(args))}}
-            if c > 1 then for i=1, c-1 do registers[a+i-1] = res[i] end end
-        elseif op == {self.opcodes.index('RETURN')} then
-            running = false
+            if {V_C} > 1 then for i=1, {V_C}-1 do {V_REGS}[{V_A}+i-1] = res[i] end end
+        elseif {V_OP} == {self.to_expr(self.opcodes.index('RETURN'))} then
+            {V_RUN} = false
         end
         
-        -- Bogus execution path to confuse static analysis
-        if op == -999 then
-            running = false
-        end
+        -- Anti-Trace Junk
+        if not ({self.opaque_predicate()}) then {V_RUN} = false end
     end
 end
 
-task.spawn(_EXECUTE)
+task.spawn({V_EXEC})
 """
         return vm_lua
 
@@ -206,7 +264,9 @@ task.spawn(_EXECUTE)
         
         def add_const(val):
             if isinstance(val, str):
-                if (val.startswith("'") and val.endswith("'")) or (val.startswith("\"") and val.endswith("\"")):
+                s_q = chr(39)
+                d_q = chr(34)
+                if (val.startswith(s_q) and val.endswith(s_q)) or (val.startswith(d_q) and val.endswith(d_q)):
                     val = val[1:-1]
             
             for i, c in enumerate(constants):
diff --git a/test_supreme.py b/test_supreme.py
new file mode 100644
index 0000000..b173f3f
--- /dev/null
+++ b/test_supreme.py
@@ -0,0 +1,21 @@
+from core.obfuscator import obfuscate
+
+code = """
+local a = 10
+local b = 20
+local c = a + b
+print("Sum is:", c)
+"""
+
+obfuscated = obfuscate(code)
+print(obfuscated)
+
+# Check for some patterns
+if "_l1" in obfuscated or "_I0" in obfuscated:
+    print("SUCCESS: Variable renaming detected.")
+if "bit32.bxor" in obfuscated or "+" in obfuscated or "-" in obfuscated:
+    # Check if it's in the VM logic, not just the original code (which might have +)
+    # The VM logic uses to_expr for indices and keys.
+    print("SUCCESS: Number expressions detected.")
+if "math.pi" in obfuscated or "math.sqrt" in obfuscated:
+    print("SUCCESS: Opaque predicates detected.")