bolone-sengkuni/hermes-brutal-mod/cheat-lua-encryption

-- encrypt.lua
function xor_encrypt(data, key)
    local result = {}
    for i = 1, #data do
        local byte = string.byte(data, i)
        local key_byte = string.byte(key, ((i - 1) % #key) + 1)
        table.insert(result, string.char(bit32.bxor(byte, key_byte)))
    end
    return table.concat(result)
end
 
-- Usage
local script = [[
gg.searchNumber("1000", gg.TYPE_DWORD)
gg.refineNumber("900", gg.TYPE_DWORD)
local r = gg.getResults(10)
for i,v in ipairs(r) do v.value = "999999" end
gg.setValues(r)
]]
 
local key = "MySecretKey123"
local encrypted = xor_encrypt(script, key)
print("Encrypted:", encrypted)
 
-- Decrypt and execute
local decrypted = xor_encrypt(encrypted, key) -- XOR is reversible
load(decrypted)()

-- aes_encrypt.lua
local crypto = require("crypto")
 
function aes_encrypt(plaintext, key)
    local cipher = crypto.encrypt("aes-256-cbc", plaintext, key, key:sub(1,16))
    return crypto.hex(cipher)
end
 
function aes_decrypt(ciphertext, key)
    local raw = crypto.unhex(ciphertext)
    return crypto.decrypt("aes-256-cbc", raw, key, key:sub(1,16))
end
 
-- Usage
local script = "gg.searchNumber('1000', gg.TYPE_DWORD)"
local key = "SuperSecretKey1234567890123456" -- 32 bytes for AES-256
local enc = aes_encrypt(script, key)
print("Encrypted (hex):", enc)
 
local dec = aes_decrypt(enc, key)
load(dec)()

# Compile Lua to bytecode (harder to reverse)
luac -o cheat_encrypted.luac cheat.lua
 
# Load bytecode in GameGuardian
local chunk = load(io.open("cheat_encrypted.luac", "rb"):read("*a"))
chunk()

// rc4.cpp
#include <vector>
#include <string>
 
std::vector<unsigned char> rc4(const std::vector<unsigned char>& data, const std::string& key) {
    std::vector<unsigned char> S(256);
    std::vector<unsigned char> result;
    
    // KSA
    for (int i = 0; i < 256; i++) S[i] = i;
    int j = 0;
    for (int i = 0; i < 256; i++) {
        j = (j + S[i] + key[i % key.length()]) % 256;
        std::swap(S[i], S[j]);
    }
    
    // PRGA
    int i = 0; j = 0;
    for (size_t n = 0; n < data.size(); n++) {
        i = (i + 1) % 256;
        j = (j + S[i]) % 256;
        std::swap(S[i], S[j]);
        result.push_back(data[n] ^ S[(S[i] + S[j]) % 256]);
    }
    return result;
}
 
// Encrypt cheat function code at runtime
void ExecuteEncryptedCheat() {
    std::string key = "CheatKey2024";
    std::vector<unsigned char> encrypted_code = {/* encrypted shellcode */};
    
    auto decrypted = rc4(encrypted_code, key);
    
    // Allocate executable memory
    LPVOID exec = VirtualAlloc(NULL, decrypted.size(), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    memcpy(exec, decrypted.data(), decrypted.size());
    
    // Execute
    ((void(*)())exec)();
}

# luraph_decrypt.py
import re
def deobfuscate_luraph(code):
    # Remove junk strings
    code = re.sub(r'local [a-z]+ = ""[^;]+;', '', code)
    
    # Decode string table
    strings = re.findall(r'"([^"]+)"', code)
    for i, s in enumerate(strings):
        code = code.replace(f'_G[{i}]', f'"{s}"')
    
    # Simplify variable names
    vars = {}
    for match in re.finditer(r'local ([a-z_]+) = ', code):
        if match.group(1) not in vars:
            vars[match.group(1)] = f'var{len(vars)}'
    
    for old, new in vars.items():
        code = code.replace(old, new)
    
    return code
# Usage
with open("obfuscated.lua", "r") as f:
    obf_code = f.read()
clean = deobfuscate_luraph(obf_code)
with open("deobfuscated.lua", "w") as f:
    f.write(clean)

# Clone decompiler
git clone https://github.com/Rerumu/Ironbrew-Deobfuscator
cd Ironbrew-Deobfuscator
 
# Deobfuscate
lua main.lua input.lua output.lua

-- polymorphic_loader.lua
function generate_loader(encrypted_script, key)
    local template = [[
local k,e,r="%s","%s",{}
for i=1,#e,2 do 
    local b=tonumber(e:sub(i,i+1),16)
    local kb=k:byte(((i-1)/2%%#k)+1)
    r[#r+1]=string.char(bit32.bxor(b,kb))
end
load(table.concat(r))()
]]
    
    -- Generate random variable names
    local vars = {"k","e","r"}
    for i=1,#vars do
        local new_var = string.char(math.random(97,122))..math.random(100,999)
        template = template:gsub(vars[i], new_var)
    end
    
    return string.format(template, key, encrypted_script)
end
 
-- Usage: Creates different loader code each time
local enc_script = "48656C6C6F" -- hex encoded
local loader1 = generate_loader(enc_script, "key1")
local loader2 = generate_loader(enc_script, "key1") -- Different code, same result

// obfuscated_strings.h
#define OBFUSCATE(str) []() { \
    constexpr auto encrypted = xor_compile_time(str); \
    return xor_runtime(encrypted); \
}()
 
// Usage in cheat
const char* cheat_name = OBFUSCATE("MyAwesomeCheat");
const char* proc_name = OBFUSCATE("game.exe");

# Test encryption/decryption
lua encrypt.lua && lua decrypt.lua
 
# Check if obfuscated Lua runs
lua obfuscated.lua