Clean PR: Remove scripts and keep essential code improvements #2

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged

stayaway245 merged 39 commits into main from mentat-0-2-clean-production-code

Apr 15, 2025

CMakeLists.txt

-Original file line number
+Diff line change
@@ Expand Up @@
         message(STATUS "Using bundled LuaFileSystem implementation")
         add_library(lfs_obj OBJECT ${CMAKE_SOURCE_DIR}/source/lfs.c)
         target_include_directories(lfs_obj PRIVATE
-            ${CMAKE_SOURCE_DIR}/source/cpp/luau
             ${CMAKE_SOURCE_DIR}/source
+            ${CMAKE_SOURCE_DIR}/source/lua_stub
         )
         target_compile_definitions(lfs_obj PRIVATE LUA_COMPAT_5_1=1)
     endif()
@@ Expand Down Expand Up / @@ -383,7 +383,14 @@ endif() @@
     message(STATUS "Building iOS Roblox Executor with real implementations (no stubs)")
     # Include our wrapper files directly
-    add_library(lua_wrapper STATIC source/lua_wrapper.c)
-    target_include_directories(lua_wrapper PUBLIC source)
+    add_library(lua_wrapper STATIC
+        source/lua_wrapper.c
+        source/lua_wrapper_impl.c
+    )
+    target_include_directories(lua_wrapper PUBLIC
+        source
+        source/lua_stub
+    )
     # Link the wrapper with the main library
     target_link_libraries(roblox_executor PRIVATE lua_wrapper)

fix_lua_includes.sh

This file was deleted.

patch_lfs.sh

This file was deleted.

source/cpp/CMakeLists.txt

-Original file line number
+Diff line change
@@ -1,7 +1,7 @@
     # Minimal CMakeLists.txt for source/cpp in CI builds
     # Check if this is a CI build
-    if(DEFINED ENV{CI} OR DEFINED BUILD_CI OR DEFINED CI_BUILD)
+    #if 0
       add_definitions(-DCI_BUILD)
       message(STATUS "CI Build detected - using stub implementation")
@@ Expand Down @@

source/cpp/anti_detection/obfuscator.hpp

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -1,177 +1,19 @@
  
    #pragma once

    #include <cstdint>

    #include <functional>

    #include <string>

    #include <vector>

    #include <random>

    #include <chrono>

    namespace AntiDetection {

        class Obfuscator {

        private:

            // Random number generator

            static std::mt19937& GetRNG() {

                static std::random_device rd;

                static std::mt19937 gen(rd());

                return gen;

            }

            // Generate a random number in range

            static int RandomInt(int min, int max) {

                std::uniform_int_distribution<> distrib(min, max);

                return distrib(GetRNG());

            }

        public:

            // Obfuscate a Lua script with various techniques

            static std::string ObfuscateLuaScript(const std::string& script) {

                // We'll implement several obfuscation techniques:

                // 1. Variable name randomization

                // 2. String encryption

                // 3. Control flow obfuscation

                // 4. Dead code insertion

                // For this example, let's implement a simple string encryption

                std::string obfuscated = "-- Obfuscated with advanced techniques\n";

                // Generate a random encryption key (1-255)

                int key = RandomInt(1, 255);

                // Create the decryption function

                obfuscated += "local function _d(s,k)\n";

                obfuscated += "    local r=''\n";

                obfuscated += "    for i=1,#s do\n";

                obfuscated += "        local c=string.byte(s,i)\n";

                obfuscated += "        r=r..string.char(c~k)\n";

                obfuscated += "    end\n";

                obfuscated += "    return r\n";

                obfuscated += "end\n\n";

                // Encrypt the original script

                std::string encrypted;

                for (char c : script) {

                    encrypted += static_cast<char>(c ^ key);

                }

                // Convert encrypted string to hex representation

                std::string hexEncrypted;

                char hexBuf[3];

                for (char c : encrypted) {

                    snprintf(hexBuf, sizeof(hexBuf), "%02X", static_cast<unsigned char>(c));

                    hexEncrypted += hexBuf;

                }

                // Add the encrypted script and decryption call

                obfuscated += "local _s=''\n";

                // Split the hex string into chunks to avoid long lines

                const int CHUNK_SIZE = 100;

                for (size_t i = 0; i < hexEncrypted.length(); i += CHUNK_SIZE) {

                    obfuscated += "    _s=_s..'" + hexEncrypted.substr(i, CHUNK_SIZE) + "'\n";

                }

                // Add the decoding and execution

                obfuscated += "\n";

                obfuscated += "local _h=''\n";

                obfuscated += "for i=1,#_s,2 do\n";

                obfuscated += "    _h=_h..string.char(tonumber(_s:sub(i,i+1),16))\n";

                obfuscated += "end\n";

                obfuscated += "\n";

                obfuscated += "local _f=_d(_h," + std::to_string(key) + ")\n";

                obfuscated += "local _x=loadstring or load\n";

                obfuscated += "return _x(_f)()\n";

                return obfuscated;

            }

            // Encode bytecode with a custom encoder to bypass detection

            static std::vector<uint8_t> ObfuscateBytecode(const std::vector<uint8_t>& bytecode) {

                std::vector<uint8_t> obfuscated;

                obfuscated.reserve(bytecode.size());

                // Simple XOR encryption with a random key for this example

                uint8_t key = static_cast<uint8_t>(RandomInt(1, 255));

                // First byte is our key

                obfuscated.push_back(key);

                // Encrypt the rest with XOR

                for (uint8_t byte : bytecode) {

                    obfuscated.push_back(byte ^ key);

                }

                return obfuscated;

            // Basic obfuscation for identifiers

            static std::string ObfuscateIdentifiers(const std::string& script) {

                // Simple implementation - in real code you'd do more

                return script;

            }

            // Create dummy functions to confuse static analysis

            // Add dead code to confuse analysis

            static std::string AddDeadCode(const std::string& script) {

                std::string result = script;

                // Add some random unused functions that look legitimate

                std::vector<std::string> dummyFunctions = {

                    "local function initializeServices()\n    local services = {}\n    services.Workspace = game:GetService('Workspace')\n    services.Players = game:GetService('Players')\n    services.RunService = game:GetService('RunService')\n    return services\nend\n",

                    "local function calculateDistance(p1, p2)\n    return (p1 - p2).Magnitude\nend\n",

                    "local function processPlayerData(player)\n    if not player then return nil end\n    return {Name = player.Name, ID = player.UserId}\nend\n"

                };

                // Insert 1 to 3 dummy functions at random positions

                int numFuncs = RandomInt(1, 3);

                for (int i = 0; i < numFuncs; i++) {

                    int funcIndex = RandomInt(0, dummyFunctions.size() - 1);

                    result = dummyFunctions[funcIndex] + result;

                }

                return result;

            }

        };

        // Anti-debugging techniques

        class AntiDebug {

        public:

            // Check for common debugging flags and tools

            static bool IsDebuggerPresent() {

                // This is platform specific - this example assumes Android

                // Check for common debugging indicators

                FILE* fp = fopen("/proc/self/status", "r");

                if (fp) {

                    char line[256];

                    while (fgets(line, sizeof(line), fp)) {

                        if (strstr(line, "TracerPid:")) {

                            int pid = 0;

                            sscanf(line, "TracerPid: %d", &pid);

                            fclose(fp);

                            return pid != 0;  // If non-zero, a debugger is attached

                        }

                    }

                    fclose(fp);

                }

                return false;

            }

            // Apply various anti-tampering checks

            static void ApplyAntiTamperingMeasures() {

                // This function would implement various integrity checks

                // 1. Check if critical functions have been modified

                // 2. Verify the integrity of key components

                // 3. Periodically scan memory for unauthorized modifications

                // For demonstration, we'll just check for debuggers

                if (IsDebuggerPresent()) {

                    // In a real implementation, you might take action like

                    // crashing the app or disabling functionality

                    // We'll just log for now

                    fprintf(stderr, "Debugger detected, enforcing countermeasures\n");

                    // In a real implementation, you might intentionally:

                    // - Corrupt memory

                    // - Jump to invalid code

                    // - Yield false results from key functions

                    // - Delay detection response to confuse reverse engineers

                }

                // Simple implementation - in real code you'd add fake branches

                return script;

            }

        };

    }

source/cpp/bridge/lua_isolation.h

-Original file line number
+Diff line change
@@ -0,0 +1,32 @@
+    // Lua isolation header - Include this when you need Lua functionality
+    #pragma once
+    // This header safely includes all Lua headers and prevents conflicts with Objective-C
+    // Guard against including both Lua and Objective-C in the same translation unit
+    #ifdef __OBJC__
+        #error "lua_isolation.h should not be included in Objective-C++ files. Use the bridge interface instead."
+    #endif
+    // Include real Lua headers directly
+    #include "../luau/lua.h"
+    #include "../luau/lualib.h"
+    #include "../luau/luaconf.h"
+    #include "../luau/lauxlib.h"
+    #include "../luau/lstate.h"
+    // Export the important types and functions that might be needed by the bridge
+    namespace LuaBridge {
+        // Use the actual lua_State type
+        using LuaState = lua_State;
+        // Functions to safely execute Lua code without exposing Lua types
+        bool ExecuteScript(lua_State* L, const char* script, const char* chunkname = "");
+        const char* GetLastError(lua_State* L);
+        // Memory management
+        void CollectGarbage(lua_State* L);
+        // Create a safely wrapped C function to expose to the bridge
+        void RegisterFunction(lua_State* L, const char* name, int (*func)(lua_State*));
+    }

source/cpp/bridge/lua_objc_bridge.cpp

-Original file line number
+Diff line change
@@ -0,0 +1,68 @@
+    // Bridge implementation for safely communicating between Lua and Objective-C
+    #include "lua_isolation.h"
+    #include "objc_isolation.h"
+    #include <string>
+    #include <vector>
+    // Implementation of LuaBridge functions
+    namespace LuaBridge {
+        bool ExecuteScript(lua_State* L, const char* script, const char* chunkname) {
+            // Directly use real Lua API since we're in a Lua-enabled compilation unit
+            int status = luaL_loadbuffer(L, script, strlen(script), chunkname);
+            if (status != 0) {
+                return false;
+            }
+            status = lua_pcall(L, 0, 0, 0);
+            return status == 0;
+        }
+        const char* GetLastError(lua_State* L) {
+            if (lua_gettop(L) > 0 && lua_isstring(L, -1)) {
+                return lua_tostring(L, -1);
+            }
+            return "Unknown error";
+        }
+        void CollectGarbage(lua_State* L) {
+            lua_gc(L, LUA_GCCOLLECT, 0);
+        }
+        void RegisterFunction(lua_State* L, const char* name, int (*func)(lua_State*)) {
+            lua_pushcfunction(L, func, name);
+            lua_setglobal(L, name);
+        }
+    }
+    // Implementation of ObjCBridge functions
+    namespace ObjCBridge {
+        // These would normally be implemented in Objective-C++ files
+        // Here we provide stub implementations for testing
+        bool ShowAlert(const char* title, const char* message) {
+            // In a real implementation, this would create a UIAlertController
+            printf("ALERT: %s - %s\n", title, message);
+            return true;
+        }
+        bool SaveScript(const char* name, const char* script) {
+            // In a real implementation, this would use NSFileManager
+            printf("SAVE SCRIPT: %s\n", name);
+            return true;
+        }
+        const char* LoadScript(const char* name) {
+            // In a real implementation, this would use NSFileManager
+            static std::string script = "-- Loaded script content";
+            return script.c_str();
+        }
+        bool InjectFloatingButton() {
+            // In a real implementation, this would create and add a UIButton
+            printf("INJECT FLOATING BUTTON\n");
+            return true;
+        }
+        void ShowScriptEditor() {
+            // In a real implementation, this would present a UIViewController
+            printf("SHOW SCRIPT EDITOR\n");
+        }
+    }

source/cpp/bridge/objc_isolation.h

-Original file line number
+Diff line change
@@ -0,0 +1,41 @@
+    // Objective-C isolation header - Include this when you need iOS functionality
+    #pragma once
+    // This header safely includes all Objective-C headers and prevents conflicts with Lua
+    // Include real iOS/macOS headers
+    #ifdef __OBJC__
+        #import <Foundation/Foundation.h>
+        #import <UIKit/UIKit.h>
+    #else
+        // Forward declarations for C++ files that need to reference but not access these types
+        #ifdef __cplusplus
+        extern "C" {
+        #endif
+        // Forward declare Objective-C types to prevent name conflicts
+        typedef struct objc_object* id;
+        typedef struct objc_class* Class;
+        typedef struct objc_selector* SEL;
+        // Forward declare common iOS types
+        typedef id NSString;
+        typedef id UIView;
+        typedef id UIViewController;
+        #ifdef __cplusplus
+        }
+        #endif
+    #endif
+    // Export bridge functions that can be called from Lua-using code
+    namespace ObjCBridge {
+        // Safe wrapper functions that don't expose iOS types in their interface
+        bool ShowAlert(const char* title, const char* message);
+        bool SaveScript(const char* name, const char* script);
+        const char* LoadScript(const char* name);
+        // UI integration
+        bool InjectFloatingButton();
+        void ShowScriptEditor();
+    }

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Clean PR: Remove scripts and keep essential code improvements #2

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!

Uh oh!

Uh oh!