robloxmemoryapi 0.0.1__tar.gz

robloxmemoryapi-0.0.1/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2025 upio, mstudio45, master oogway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

robloxmemoryapi-0.0.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: robloxmemoryapi
+Version: 0.0.1
+Summary: Python Library that abstracts reading data from the Roblox DataModel
+Author-email: upio <notpoiu@users.noreply.github.com>, mstudio45 <mstudio45@users.noreply.github.com>, ActualMasterOogway <ActualMasterOogway@users.noreply.github.com>
+License: Copyright 2025 upio, mstudio45, master oogway
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/notpoiu/RobloxMemoryAPI
+Project-URL: Issues, https://github.com/notpoiu/RobloxMemoryAPI/issues
+Keywords: roblox,memory,windows
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: requests>=2.0
+Dynamic: license-file
+
+# RobloxMemoryAPI
+
+A Python library that is _hopefully stealthy_ and abstracts externally reading memory to get datamodel information from the roblox game client.
+
+This was made by [upio](https://github.com/notpoiu), [mstudio45](https://github.com/mstudio45), and [Master Oogway](https://github.com/ActualMasterOogway) and created for the [Dig Macro](https://github.com/mstudio45/digmacro) project (external mode and not the computer vision mode).
+
+## Installation
+
+PyPI:
+
+```bash
+pip install robloxmemoryapi
+```
+
+Development (editable install from source):
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+An example script can be found in [example.py](example.py). If running from the repo, use the editable install above so `import robloxmemoryapi` resolves the `src` package.
+
+Import the library and create a client instance:
+
+```python
+from robloxmemoryapi import RobloxGameClient
+
+client = RobloxGameClient()
+```
+
+Access the data model:
+
+```python
+game = client.DataModel
+```
+
+Get the local player's name:
+
+```python
+print("Player Name:", game.Players.LocalPlayer.Name)
+```
+
+## License
+
+This project is licensed under the MIT License.

robloxmemoryapi-0.0.1/README.md

@@ -0,0 +1,47 @@
+# RobloxMemoryAPI
+
+A Python library that is _hopefully stealthy_ and abstracts externally reading memory to get datamodel information from the roblox game client.
+
+This was made by [upio](https://github.com/notpoiu), [mstudio45](https://github.com/mstudio45), and [Master Oogway](https://github.com/ActualMasterOogway) and created for the [Dig Macro](https://github.com/mstudio45/digmacro) project (external mode and not the computer vision mode).
+
+## Installation
+
+PyPI:
+
+```bash
+pip install robloxmemoryapi
+```
+
+Development (editable install from source):
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+An example script can be found in [example.py](example.py). If running from the repo, use the editable install above so `import robloxmemoryapi` resolves the `src` package.
+
+Import the library and create a client instance:
+
+```python
+from robloxmemoryapi import RobloxGameClient
+
+client = RobloxGameClient()
+```
+
+Access the data model:
+
+```python
+game = client.DataModel
+```
+
+Get the local player's name:
+
+```python
+print("Player Name:", game.Players.LocalPlayer.Name)
+```
+
+## License
+
+This project is licensed under the MIT License.

robloxmemoryapi-0.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "robloxmemoryapi"
+version = "0.0.1"
+description = "Python Library that abstracts reading data from the Roblox DataModel"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.9"
+license = { file = "LICENSE.md" }
+authors = [
+  { name = "upio", email = "notpoiu@users.noreply.github.com" },
+  { name = "mstudio45", email = "mstudio45@users.noreply.github.com" },
+  { name = "ActualMasterOogway", email = "ActualMasterOogway@users.noreply.github.com" },
+]
+keywords = ["roblox", "memory", "windows"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: Microsoft :: Windows",
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+  "requests>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/notpoiu/RobloxMemoryAPI"
+Issues = "https://github.com/notpoiu/RobloxMemoryAPI/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+robloxmemoryapi = ["data/*.json"]
+

robloxmemoryapi-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

robloxmemoryapi-0.0.1/src/robloxmemoryapi/__init__.py

@@ -0,0 +1,87 @@
+import platform
+import math
+
+__all__ = ["RobloxRandom", "RobloxGameClient", "__version__"]
+__version__ = "0.1.0"
+
+
+class RobloxRandom:
+    MULT = 6364136223846793005
+    INC = 105
+    MASK64 = (1 << 64) - 1
+
+    def __init__(self, seed):
+        s = math.floor(seed)
+
+        self._state = 0
+        self._inc = RobloxRandom.INC
+        self._next_internal()         # warm-up #1
+        self._state = (self._state + s) & RobloxRandom.MASK64
+        self._next_internal()         # warm-up #2
+
+    def _next_internal(self):
+        old = self._state
+        self._state = (old * RobloxRandom.MULT + self._inc) & RobloxRandom.MASK64
+        x = ((old >> 18) ^ old) >> 27
+        r = old >> 59
+        return ((x >> r) | (x << ((32 - r) & 31))) & 0xFFFFFFFF
+
+    def _next_fraction64(self):
+        lo = self._next_internal()
+        hi = self._next_internal()
+        bits = (hi << 32) | lo
+        return bits / 2**64
+
+    def NextNumber(self, minimum=0.0, maximum=1.0):
+        frac = self._next_fraction64()
+        return minimum + frac * (maximum - minimum)
+
+    def NextInteger(self, a, b=None):
+        if b is None:
+            u = a
+            r = self._next_internal()
+            return ((u * r) >> 32) + 1
+        else:
+            lo, hi = (a, b) if a <= b else (b, a)
+            u = hi - lo + 1
+            r = self._next_internal()
+            return ((u * r) >> 32) + lo
+
+
+class RobloxGameClient:
+    def __init__(self, pid: int = None, process_name: str = "RobloxPlayerBeta.exe"):
+        if platform.system() != "Windows":
+            self.failed = True
+            return
+
+        from .utils.memory import (
+            EvasiveProcess,
+            PROCESS_QUERY_INFORMATION,
+            PROCESS_VM_READ,
+            get_pid_by_name,
+        )
+
+        if pid is None:
+            self.pid = get_pid_by_name(process_name)
+        else:
+            self.pid = pid
+
+        if self.pid is None or self.pid == 0:
+            raise ValueError("Failed to get PID.")
+
+        self.memory_module = EvasiveProcess(self.pid, PROCESS_VM_READ | PROCESS_QUERY_INFORMATION)
+        self.failed = False
+
+    def close(self):
+        self.memory_module.close()
+
+    @property
+    def DataModel(self):
+        if platform.system() != "Windows":
+            raise RuntimeError("This module is only compatible with Windows.")
+        elif self.failed:
+            raise RuntimeError("There was an error while getting access to memory. Please try again later.")
+
+        from .utils.rbx.instance import DataModel
+        return DataModel(self.memory_module)
+

robloxmemoryapi-0.0.1/src/robloxmemoryapi/data/offsets.json

@@ -0,0 +1,6 @@
+{
+    "Text": "0xC10",
+    "Character": "0x328",
+    "PrimaryPart": "0x268"
+}
+

robloxmemoryapi-0.0.1/src/robloxmemoryapi/utils/__init__.py

@@ -0,0 +1,2 @@
+# Utility subpackage for memory access and offsets
+

robloxmemoryapi-0.0.1/src/robloxmemoryapi/utils/memory.py

@@ -0,0 +1,275 @@
+import ctypes
+import struct
+from ctypes import wintypes
+
+ntdll = ctypes.WinDLL('ntdll.dll')
+psapi = ctypes.WinDLL('psapi.dll')
+kernel32 = ctypes.WinDLL('kernel32.dll')
+
+kernel32.VirtualAlloc.restype = wintypes.LPVOID
+kernel32.VirtualAlloc.argtypes = [wintypes.LPVOID, ctypes.c_size_t, wintypes.DWORD, wintypes.DWORD]
+kernel32.GetProcAddress.restype = wintypes.LPVOID
+kernel32.GetProcAddress.argtypes = [wintypes.HMODULE, wintypes.LPCSTR]
+
+NTSTATUS = wintypes.LONG
+HANDLE = wintypes.HANDLE
+DWORD = wintypes.DWORD
+LPVOID = wintypes.LPVOID
+HMODULE = wintypes.HMODULE
+BOOL = wintypes.BOOL
+
+PROCESS_QUERY_INFORMATION = 0x0400
+PROCESS_VM_READ = 0x0010
+LIST_MODULES_ALL = 0x03
+STATUS_SUCCESS = 0
+MEM_COMMIT = 0x1000
+MEM_RESERVE = 0x2000
+PAGE_EXECUTE_READWRITE = 0x40
+NTDLL_HANDLE = ntdll._handle
+
+class CLIENT_ID(ctypes.Structure):
+    _fields_ = [
+        ("UniqueProcess", HANDLE),
+        ("UniqueThread", HANDLE),
+    ]
+
+class OBJECT_ATTRIBUTES(ctypes.Structure):
+    _fields_ = [
+        ("Length", wintypes.ULONG),
+        ("RootDirectory", HANDLE),
+        ("ObjectName", LPVOID),
+        ("Attributes", wintypes.ULONG),
+        ("SecurityDescriptor", LPVOID),
+        ("SecurityQualityOfService", LPVOID),
+    ]
+
+def get_syscall_number(function_name: str) -> int | None:
+    func_address = kernel32.GetProcAddress(NTDLL_HANDLE, function_name.encode('ascii'))
+    if not func_address:
+        return None
+    buffer = (ctypes.c_ubyte * 8).from_address(func_address)
+    if tuple(buffer[0:4]) == (0x4c, 0x8b, 0xd1, 0xb8):
+        return int.from_bytes(bytes(buffer[4:8]), 'little')
+    return None
+
+def create_syscall_function(syscall_number, func_prototype):
+    assembly_stub = b'\x4C\x8B\xD1' + \
+                    b'\xB8' + syscall_number.to_bytes(4, 'little') + \
+                    b'\x0F\x05' + \
+                    b'\xC3'
+
+    exec_mem = kernel32.VirtualAlloc(None, len(assembly_stub), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE)
+    if not exec_mem:
+        raise ctypes.WinError(ctypes.get_last_error())
+    ctypes.memmove(exec_mem, assembly_stub, len(assembly_stub))
+    return func_prototype(exec_mem)
+
+NtOpenProcessProto = ctypes.WINFUNCTYPE(
+    NTSTATUS,
+    ctypes.POINTER(HANDLE),
+    DWORD,
+    ctypes.POINTER(OBJECT_ATTRIBUTES),
+    ctypes.POINTER(CLIENT_ID)
+)
+NtReadVirtualMemoryProto = ctypes.WINFUNCTYPE(
+    NTSTATUS,
+    HANDLE,
+    LPVOID,
+    LPVOID,
+    ctypes.c_ulong,
+    ctypes.POINTER(ctypes.c_ulong)
+)
+NtCloseProto = ctypes.WINFUNCTYPE(NTSTATUS, HANDLE)
+
+syscall_id_open = get_syscall_number("NtOpenProcess")
+syscall_id_read = get_syscall_number("NtReadVirtualMemory")
+syscall_id_close = get_syscall_number("NtClose")
+
+if not all([syscall_id_open, syscall_id_read, syscall_id_close]):
+    raise RuntimeError("Could not find required syscall numbers.")
+
+nt_open_process_syscall = create_syscall_function(syscall_id_open, NtOpenProcessProto)
+nt_read_virtual_memory_syscall = create_syscall_function(syscall_id_read, NtReadVirtualMemoryProto)
+nt_close_syscall = create_syscall_function(syscall_id_close, NtCloseProto)
+
+psapi.EnumProcessModulesEx.argtypes = [
+    HANDLE,
+    ctypes.POINTER(HMODULE),
+    DWORD,
+    ctypes.POINTER(DWORD),
+    DWORD
+]
+psapi.EnumProcessModulesEx.restype = BOOL
+
+def _get_module_base(process_handle: HANDLE) -> int:
+    try:
+        modules_arr_size = 256
+        modules_arr = (HMODULE * modules_arr_size)()
+        needed = DWORD(0)
+        psapi.EnumProcessModulesEx(
+            process_handle,
+            modules_arr,
+            ctypes.sizeof(modules_arr),
+            ctypes.byref(needed),
+            LIST_MODULES_ALL
+        )
+        if needed.value > ctypes.sizeof(modules_arr):
+            new_size = needed.value // ctypes.sizeof(HMODULE)
+            modules_arr = (HMODULE * new_size)()
+            success = psapi.EnumProcessModulesEx(
+                process_handle,
+                modules_arr,
+                ctypes.sizeof(modules_arr),
+                ctypes.byref(needed),
+                LIST_MODULES_ALL
+            )
+            if not success:
+                return 0
+        if needed.value > 0:
+            return modules_arr[0] if modules_arr[0] else 0
+        return 0
+    except Exception as e:
+        print(f"An exception occurred in _get_module_base: {e}")
+        return 0
+   
+def get_pid_by_name(process_name: str) -> int:
+    class PROCESSENTRY32(ctypes.Structure):
+        _fields_ = [
+            ("dwSize", DWORD),
+            ("cntUsage", DWORD),
+            ("th32ProcessID", DWORD),
+            ("th32DefaultHeapID", ctypes.POINTER(wintypes.ULONG)),
+            ("th32ModuleID", DWORD),
+            ("cntThreads", DWORD),
+            ("th32ParentProcessID", DWORD),
+            ("pcPriClassBase", wintypes.LONG),
+            ("dwFlags", DWORD),
+            ("szExeFile", wintypes.CHAR * 260)
+        ]
+    snapshot = kernel32.CreateToolhelp32Snapshot(2, 0)
+    if not snapshot or snapshot == wintypes.HANDLE(-1).value:
+        raise ctypes.WinError()
+    entry = PROCESSENTRY32()
+    entry.dwSize = ctypes.sizeof(PROCESSENTRY32)
+    try:
+        if not kernel32.Process32First(snapshot, ctypes.byref(entry)):
+            return 0
+        while True:
+            if entry.szExeFile.decode('utf-8', errors='ignore') == process_name:
+                return entry.th32ProcessID
+            if not kernel32.Process32Next(snapshot, ctypes.byref(entry)):
+                break
+    finally:
+        kernel32.CloseHandle(snapshot)
+    return 0
+
+class EvasiveProcess:
+    def __init__(self, pid: int, access: DWORD):
+        self.pid = pid
+        self.access = access
+        self.handle = HANDLE(0)
+        self.base = 0
+
+        object_attributes = OBJECT_ATTRIBUTES()
+        client_id = CLIENT_ID()
+        client_id.UniqueProcess = HANDLE(pid)
+        object_attributes.Length = ctypes.sizeof(OBJECT_ATTRIBUTES)
+
+        status = nt_open_process_syscall(
+            ctypes.byref(self.handle),
+            access,
+            ctypes.byref(object_attributes),
+            ctypes.byref(client_id)
+        )
+        if status != STATUS_SUCCESS:
+            raise ctypes.WinError(f"NtOpenProcess failed with NTSTATUS: 0x{status:X}")
+        self.base = _get_module_base(self.handle)
+        if self.base == 0:
+            self.close()
+            raise ConnectionError("Failed to get module base address.")
+
+    def read(self, address: int, size: int) -> bytes:
+        if not self.handle or self.handle.value == 0:
+            raise ValueError("Process handle is not valid.")
+        buffer = ctypes.create_string_buffer(size)
+        bytes_read = ctypes.c_ulong(0)
+        status = nt_read_virtual_memory_syscall(
+            self.handle,
+            LPVOID(address),
+            buffer,
+            size,
+            ctypes.byref(bytes_read)
+        )
+        if status != STATUS_SUCCESS:
+            raise OSError(f"NtReadVirtualMemory failed with NTSTATUS: 0x{status:X}")
+        return buffer.raw[:bytes_read.value]
+
+    # numbers #
+    def read_int(self, address: int) -> int:
+        buffer = self.read(address, 4)
+        return int.from_bytes(buffer, 'little') if len(buffer) == 4 else 0
+        
+    def read_long(self, address: int) -> int:
+        buffer = self.read(address, 8)
+        return int.from_bytes(buffer, 'little') if len(buffer) == 8 else 0
+    
+    def read_double(self, address: int) -> float:
+        try:
+            double_bytes = self.read(address, 8)
+            return struct.unpack('<d', double_bytes)[0] if len(double_bytes) == 8 else 0.0
+        except (OSError, struct.error):
+            return 0.0
+
+    def read_float(self, address: int) -> float:
+        try:
+            float_bytes = self.read(address, 4)
+            return struct.unpack('f', float_bytes)[0] if len(float_bytes) == 4 else 0.0
+        except (OSError, struct.error):
+            return 0.0
+    
+    def read_floats(self, address: int, amount: int):
+        try:
+            bulk_float_bytes = self.read(address, 4 * amount)
+            floats = []
+            for i in range(amount):
+                start_range = i * 4
+                float_bytes = bulk_float_bytes[start_range:start_range + 4]
+                
+                if len(float_bytes) == 4:
+                    floats.append(struct.unpack('f', float_bytes)[0])
+                else:
+                    floats.append(0.0)
+
+            return floats
+        except (OSError, struct.error) as e:
+            return [0.0]
+
+    # bool #
+    def read_bool(self, address: int) -> bool:
+        try:
+            bool_byte = self.read(address, 1)
+            if not bool_byte: return False
+            return bool(int.from_bytes(bool_byte, 'little'))
+        except OSError:
+            return False
+
+    # string #
+    def read_raw_string(self, address: int, max_length: int = 256) -> str:
+        buffer = self.read(address, max_length)
+        null_pos = buffer.find(b'\x00')
+        valid_bytes = buffer[:null_pos] if null_pos != -1 else buffer
+        return valid_bytes.decode('utf-8', errors='ignore')
+        
+    def read_string(self, address: int) -> str:
+        string_length = self.read_int(address + 0x10)
+        if string_length <= 15:
+            return self.read_raw_string(address, string_length)
+        else:
+            string_data_pointer = self.read_long(address)
+            return self.read_raw_string(string_data_pointer, string_length) if string_data_pointer else ""
+    
+    #########
+    def close(self):
+        if self.handle and self.handle.value != 0:
+            nt_close_syscall(self.handle)
+            self.handle = HANDLE(0)

robloxmemoryapi-0.0.1/src/robloxmemoryapi/utils/offsets.py

@@ -0,0 +1,46 @@
+import json
+import requests
+from importlib import resources
+
+Offsets = {}
+def ParseOffsets(*DataSources):
+    for _, Data in enumerate(DataSources, start=1):
+        for OffsetName in Data:
+            try:
+                FormattedOffsetName = OffsetName.replace(" ", "")
+                OffsetHexadecimalValue = Data[OffsetName]
+
+                Offsets[FormattedOffsetName] = int(OffsetHexadecimalValue, 16)
+            except (ValueError, TypeError):
+                pass
+
+
+OffsetsRequest = requests.get("https://offsets.ntgetwritewatch.workers.dev/offsets.json")
+
+try:
+    LoadedOffsetsRequest = requests.get(
+        "https://raw.githubusercontent.com/notpoiu/RobloxMemoryAPI/refs/heads/main/src/robloxmemoryapi/data/offsets.json"
+    )
+    LoadedOffsetsRequest.raise_for_status()
+
+    LoadedOffsets = LoadedOffsetsRequest.json()
+except Exception:
+    try:
+        with resources.files("robloxmemoryapi.data").joinpath("offsets.json").open("r", encoding="utf-8") as f:
+            LoadedOffsets = json.load(f)
+    except Exception:
+        # Fallback defaults
+        LoadedOffsets = {
+            "Text": "0xC10",
+            "Character": "0x328",
+            "PrimaryPart": "0x268",
+        }
+
+ParseOffsets(LoadedOffsets, OffsetsRequest.json())
+
+# CFrame Offsets
+RotationMatriciesLengthBytes = 3 * 3 * 4
+
+Offsets["CameraCFrame"] = Offsets["CameraPos"] - RotationMatriciesLengthBytes
+Offsets["CFrame"] = Offsets["Position"] - RotationMatriciesLengthBytes
+