cheat-lua-encryption

Files (1)

• SKILL.md

SKILL.md (first lines)

# Cheat & Lua Encryption/Decryption

## When to Use
Use when encrypting game cheats or Lua scripts to bypass detection, or decrypting obfuscated Lua code.

## Lua Script Encryption

### Simple XOR Encryption
```lua
-- 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 Encryption (Using LuaCrypto)
```lua
-- 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)()
```

## Lua Bytecode Compilation
```bash
# 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()
```

## Cheat DLL Encryption (Windows)

### RC4 Encrypt C++ Cheat
```cpp
// 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)();
}
```

From harezadmm/omp-enhanced, MIT.

More from harezadmm/omp-enhanced