Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

Provide multiple methods of advanced control flow obfuscation in luau with examples

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-opus-4-20250514-thinking-16k’s answer.
  1. User

    Provide multiple methods of advanced control flow obfuscation in luau with examples

  2. DeepSeek Assistant

    Advanced Control Flow Obfuscation Techniques in Luau

    Below are multiple methods with examples designed to complicate reverse engineering while preserving functionality. These techniques manipulate control flow using state machines, opaque predicates, and dynamic dispatch.


    1. State Machine-Based Control Flow Flattening

    Concept: Convert linear code into a state machine where a switch dispatches blocks based on a state variable.
    Example:

    local function calculate(x)
        local state = 0
        local result
        while true do
            if state == 0 then
                result = 0
                state = 1
            elseif state == 1 then
                if x > 10 then
                    state = 2
                else
                    state = 3
                end
            elseif state == 2 then
                result = x * 2
                state = 4
            elseif state == 3 then
                result = x + 5
                state = 4
            elseif state == 4 then
                break
            end
        end
        return result
    end
    

    2. Opaque Predicates with Junk Code

    Concept: Inject conditions that always evaluate the same way but obscure the path.
    Example:

    local function checkValue(n)
        -- Opaque predicate: (7^2 > 45) is always true
        local key = math.random(1, 10) > 5  -- Random junk
        if (7 * 7 > 45) and (key or not key) then -- Always true
            return n % 2 == 0
        else
            -- Dead code (never executed)
            return math.sin(n) > 0
        end
    end
    

    3. Function Pointer Tables & Dynamic Dispatch

    Concept: Replace direct calls with indirect calls via a table of functions.
    Example:

    local function add(a, b) return a + b end
    local function sub(a, b) return a - b end
    
    local dispatcher = {
        [1] = function(x, y) return add(x, y) end,
        [2] = function(x, y) return sub(x, y) end
    }
    
    -- Obfuscated operation
    local operation = (math.pi > 3) and 1 or 2  -- Always 1
    local result = dispatcher[operation](5, 3)  -- Returns 8
    

    4. Encrypted String Execution

    Concept: Hide strings via XOR encryption and decrypt at runtime.
    Example:

    local key = 0x55
    local encrypted = {
        string.char(0x26, 0x26, 0x71, 0x26, 0x7C),  -- "Hello"
        string.char(0x7C, 0x77, 0x61, 0x7C)         -- "World"
    }
    
    local function decrypt(data, key)
        local output = {}
        for i = 1, #data do
            output[i] = string.char(data:byte(i) ~ key)
        end
        return table.concat(output)
    end
    
    print(decrypt(encrypted[1], key) .. " " .. decrypt(encrypted[2], key))
    

    5. Dead State Insertion & Jumps

    Concept: Add unreachable states and jumps to confuse decompilers.
    Example:

    local function process(n)
        local state, next = 0, { [0]=1, [1]=3, [2]=4, [3]=999 }
        local result = 0
    
        repeat
            if state == 0 then
                result = n
                state = next[state]
            elseif state == 1 then
                state = (n > 100) and next[state] or 2  -- Dead state 2
            elseif state == 2 then  -- Unreachable
                result = math.sqrt(n)  -- Junk math
                state = next[state]
            elseif state == 3 then
                result = result * 2
                state = next[state]
            end
        until state == 999
    
        return result
    end
    

    6. Environment Sandboxing with Metatables

    Concept: Use getfenv/setfenv (deprecated but effective) to hide variables.
    Example:

    local env = {}
    setmetatable(env, { __index = function(_, k) return k == "secret" and 42 or nil end })
    
    local func = function()
        -- 'secret' is hidden in the environment
        return secret * 2
    end
    
    setfenv(func, env)
    print(func())  -- Output: 84
    

    Key Considerations:

    • Performance: Obfuscation adds overhead. Test impact in performance-critical code.
    • Roblox Compatibility: Avoid deprecated features (e.g., getfenv) in production.
    • Tool Resistance: Combine techniques to defeat automated deobfuscators.
    • Ethics: Follow Roblox's Terms of Service; obfuscation may violate rules.

    Use these methods judiciously to protect intellectual property without compromising game functionality.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.