From 33ef3d1b36f71d24f773cd608e8bf91ae46d2015 Mon Sep 17 00:00:00 2001
From: Flatlogic Bot <support@flatlogic.com>
Date: Sat, 31 Jan 2026 13:56:33 +0000
Subject: [PATCH] 14:56

---
 core/__pycache__/obfuscator.cpython-311.pyc | Bin 12057 -> 14177 bytes
 core/obfuscator.py                          | 119 ++++++++++++++++----
 2 files changed, 98 insertions(+), 21 deletions(-)

diff --git a/core/__pycache__/obfuscator.cpython-311.pyc b/core/__pycache__/obfuscator.cpython-311.pyc
index a5a306811a9196929842a6e55825e7f584a58605..0bc962adad32e58724492f7ac4ba1323991c47e7 100644
GIT binary patch
delta 5061
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
NW<vjKt<YhI{twxZ8SMZ7

delta 3332
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
A1^@s6

diff --git a/core/obfuscator.py b/core/obfuscator.py
index d30098b..b7f0d9a 100644
--- a/core/obfuscator.py
+++ b/core/obfuscator.py
@@ -14,40 +14,81 @@ class LuauVMObfuscator:
             "LT", "LE", "TEST", "TESTSET", "CALL", "TAILCALL", "RETURN",
             "FORLOOP", "FORPREP", "TFORLOOP", "SETLIST", "CLOSE", "CLOSURE", "VARARG"
         ]
-        # Randomize opcode mapping
-        self.op_order = list(range(len(self.opcodes)))
-        random.shuffle(self.op_order)
         
         # Arithmetic keys for opcode decoding
-        self.k1 = random.randint(10, 100)
-        self.k2 = random.randint(10, 100)
+        self.k1 = random.randint(50, 200)
+        self.k2 = random.randint(50, 200)
+        self.k3 = random.randint(1, 10) # Multiplier/Step
         
         # 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}
 
     def encrypt_string(self, s, key):
-        return "".join(chr(ord(c) ^ ((key + i) % 256)) for i, c in enumerate(s))
+        # More complex XOR scheme: each byte depends on previous byte and index
+        res = []
+        last = key % 256
+        for i, c in enumerate(s):
+            k = (key + i + last) % 256
+            last = ord(c)
+            res.append(chr(ord(c) ^ k))
+        return "".join(res)
 
     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
+            
+            # Pack: [OP, A, B, C, Next_L, Next_H]
+            packed = [
+                inst[0], 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 bytecode['instructions'] for i in inst)
+        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)
         for i, c in enumerate(bytecode['constants']):
             if c['type'] == 'string':
-                # Encrypt with index-based key
-                key = (i * 137 + 42) % 256
+                # 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()})
             else:
                 encrypted_consts.append({"t": 2, "v": c['value']})
         
         consts_json = json.dumps(encrypted_consts)
+        
+        # Starting shuffled index
+        start_idx = pos_map[0]
 
         vm_lua = f"""
--- [[ LUAU-VM PROTECTED ]]
+-- [[ LUAU-VM HARDENED - V2 ]]
 local _ENV = getfenv()
 local _B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
 local _D = function(data)
@@ -64,12 +105,31 @@ 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
+end
+
 local _INST_RAW = _D('{inst_b64}')
 local _CONSTS = game:GetService("HttpService"):JSONDecode('{consts_json}')
+local _SALT = {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
+    end
+
     local registers = {{}}
-    local vip = 1
+    local current = {start_idx}
     local running = true
     
     local function get_const(idx)
@@ -77,22 +137,34 @@ local function _EXECUTE()
         if not c then return nil end
         if c.t == 1 then
             local raw = _D(c.v)
-            local key = (idx * 137 + 42) % 256
+            local key = (idx * 149 + _SALT) % 256
             local res = ""
+            local last = key % 256
             for i=1, #raw do
-                res = res .. string.char(bit32.bxor(string.byte(raw, i), (key + i - 1) % 256))
+                local k = (key + i + last - 1) % 256
+                local b = string.byte(raw, i)
+                local char_code = bit32.bxor(b, k)
+                res = res .. string.char(char_code)
+                last = char_code
             end
             return res
         end
         return c.v
     end
 
-    while running and vip <= #_INST_RAW do
-        local op_raw = string.byte(_INST_RAW, vip)
-        local a = string.byte(_INST_RAW, vip + 1)
-        local b = string.byte(_INST_RAW, vip + 2)
-        local c = string.byte(_INST_RAW, vip + 3)
-        vip = vip + 4
+    -- MEGA-DISPATCH LOOP (Control-Flow Flattening)
+    while running do
+        local ptr = current * 6 + 1
+        if ptr > #_INST_RAW 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)
+        
+        current = next_l + (next_h * 256)
         
         -- Arithmetic Opcode Decoding
         local op = bit32.bxor(op_raw, {self.k2}) - {self.k1}
@@ -114,6 +186,11 @@ local function _EXECUTE()
         elseif op == {self.opcodes.index('RETURN')} then
             running = false
         end
+        
+        -- Bogus execution path to confuse static analysis
+        if op == -999 then
+            running = false
+        end
     end
 end
 
@@ -129,7 +206,7 @@ task.spawn(_EXECUTE)
         
         def add_const(val):
             if isinstance(val, str):
-                if (val.startswith('"') and val.endswith('"')) or (val.startswith("'" ) and val.endswith("'" )):
+                if (val.startswith("'") and val.endswith("'")) or (val.startswith("\"") and val.endswith("\"")):
                     val = val[1:-1]
             
             for i, c in enumerate(constants):
@@ -193,4 +270,4 @@ task.spawn(_EXECUTE)
             return f"-- Error: {str(e)}\n{traceback.format_exc()}"
 
 def obfuscate(code):
-    return LuauVMObfuscator().obfuscate(code)
\ No newline at end of file
+    return LuauVMObfuscator().obfuscate(code)