ntmemoryapi 1.7.2__tar.gz → 2.0__tar.gz

{ntmemoryapi-1.7.2 → ntmemoryapi-2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ntmemoryapi
-Version: 1.7.2
+Version: 2.0
 Summary: Simple library for Windows to manipulate process virtual memory with stelthy syscall wraps
 Author: Xenely
 Requires-Dist: psutil>=7.1.3

{ntmemoryapi-1.7.2 → ntmemoryapi-2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ntmemoryapi"
-version = "1.7.2"
+version = "2.0"
 description = "Simple library for Windows to manipulate process virtual memory with stelthy syscall wraps"
 authors = [
     {name = "Xenely"}

{ntmemoryapi-1.7.2 → ntmemoryapi-2.0}/src/ntmemoryapi/__init__.py

@@ -267,6 +267,20 @@ def list_processes(include_process_information: int = PROCESS_ID | PROCESS_NAME)
     return processes
 
 
+def __get_be_buffer(soure_c_type: typing.Any) -> ctypes.BigEndianStructure:
+    """Create buffer to hold data in big-endian format."""
+
+    class BigEndianValue(ctypes.BigEndianStructure):
+        """Big-endian value structure."""
+
+        _pack_ = 1
+        _fields_ = [
+            ("value", soure_c_type)
+        ]
+
+    return BigEndianValue
+
+
 # ==-------------------------------------------------------------------== #
 # Classes                                                                 #
 # ==-------------------------------------------------------------------== #
@@ -277,18 +291,18 @@ class Process:
     # Methods                                                                 #
     # ==-------------------------------------------------------------------== #
 
-    def __init__(self, name_or_pid: int | str, access: int = PROCESS_ALL_ACCESS) -> None:
+    def __init__(self, name_or_pid: str | int, access: int = PROCESS_ALL_ACCESS) -> None:
         """Initialize instance to manipulate process."""
 
         # Open process by it's ID or it's name
         match name_or_pid:
 
-            case int():
-                self.handle, self.pid, self.name = self.__init_with_pid(name_or_pid, access)
-
             case str():
                 self.handle, self.pid, self.name = self.__init_with_name(name_or_pid, access)
 
+            case int():
+                self.handle, self.pid, self.name = self.__init_with_pid(name_or_pid, access)
+
             case _:
                 raise Exception("Invalid `name_or_pid` argument value, have to be `int` or `str` type")
 
@@ -481,7 +495,7 @@ class Process:
         # Validate given pattern
         for byte in pattern.strip().split():
 
-            # If pattern byte is digit or wildcard
+            # If pattern byte is not wildcard and valid
             if len(byte) == 2 and [item in "0123456789ABCDEFabcdef" for item in byte].count(True) == 2:
                 continue
 
@@ -552,29 +566,29 @@ class Process:
 
         return buffer.value
 
-    def read_int16(self, address: int) -> int:
+    def read_int16(self, address: int, big_endian: bool = False) -> int:
         """Read 2 byte signed integer value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int16()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int16)() if big_endian else ctypes.c_int16()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_int32(self, address: int) -> int:
+    def read_int32(self, address: int, big_endian: bool = False) -> int:
         """Read 4 byte signed integer value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int32()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int32)() if big_endian else ctypes.c_int32()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_int64(self, address: int) -> int:
+    def read_int64(self, address: int, big_endian: bool = False) -> int:
         """Read 8 byte signed integer value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int64()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int64)() if big_endian else ctypes.c_int64()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
@@ -588,56 +602,56 @@ class Process:
 
         return buffer.value
 
-    def read_uint16(self, address: int) -> int:
+    def read_uint16(self, address: int, big_endian: bool = False) -> int:
         """Read 2 byte unsigned integer value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint16()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_uint16)() if big_endian else ctypes.c_uint16()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_uint32(self, address: int) -> int:
+    def read_uint32(self, address: int, big_endian: bool = False) -> int:
         """Read 4 byte unsigned integer value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint32()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_uint32)() if big_endian else ctypes.c_uint32()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_uint64(self, address: int) -> int:
+    def read_uint64(self, address: int, big_endian: bool = False) -> int:
         """Read 8 byte unsigned integer value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint64()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_uint64)() if big_endian else ctypes.c_uint64()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_float32(self, address: int) -> float:
+    def read_float32(self, address: int, big_endian: bool = False) -> float:
         """Read 4 byte floating-point digit value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_float()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_float)() if big_endian else ctypes.c_float()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_float64(self, address: int) -> float:
+    def read_float64(self, address: int, big_endian: bool = False) -> float:
         """Read 8 byte floating-point digit value located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_double()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_double)() if big_endian else ctypes.c_double()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return buffer.value
 
-    def read_bytes(self, address: int, size: int) -> bytes:
+    def read_bytes(self, address: int, size: int, big_endian: bool = False) -> bytes:
         """Read bytes array of variadic size located at given address."""
 
         # If result failed
-        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := (ctypes.c_int8 * size)()), ctypes.sizeof(buffer), None)):
+        if (result := _nt_read_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int8 * size)() if big_endian else (ctypes.c_int8 * size)()), ctypes.sizeof(buffer), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
         return bytes(buffer)
@@ -658,28 +672,26 @@ class Process:
         if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int8(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_int16(self, address: int, value: int) -> None:
+    def write_int16(self, address: int, value: int, big_endian: bool = False) -> None:
         """Write 2 byte signed integer value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int16(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int16(value)) if big_endian else ctypes.c_int16(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_int32(self, address: int, value: int) -> None:
+    def write_int32(self, address: int, value: int, big_endian: bool = False) -> None:
         """Write 4 byte signed integer value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int32(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int32(value)) if big_endian else ctypes.c_int32(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_int64(self, address: int, value: int) -> None:
+    def write_int64(self, address: int, value: int, big_endian: bool = False) -> None:
         """Write 8 byte signed integer value at given address."""
 
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int64(value)), ctypes.sizeof(buffer), None)):
-
-            # If result failed
-            if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_int64(value)), ctypes.sizeof(buffer), None)):
-                raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
+        # If result failed
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_int64(value)) if big_endian else ctypes.c_int64(value)), ctypes.sizeof(buffer), None)):
+            raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
     def write_uint8(self, address: int, value: int) -> None:
         """Write 1 byte unsigned integer value at given address."""
@@ -688,46 +700,46 @@ class Process:
         if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint8(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_uint16(self, address: int, value: int) -> None:
+    def write_uint16(self, address: int, value: int, big_endian: bool = False) -> None:
         """Write 2 byte unsigned integer value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint16(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_uint16(value)) if big_endian else ctypes.c_uint16(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_uint32(self, address: int, value: int) -> None:
+    def write_uint32(self, address: int, value: int, big_endian: bool = False) -> None:
         """Write 4 byte unsigned integer value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint32(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_uint32(value)) if big_endian else ctypes.c_uint32(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_uint64(self, address: int, value: int) -> None:
+    def write_uint64(self, address: int, value: int, big_endian: bool = False) -> None:
         """Write 8 byte unsigned integer value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_uint64(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_uint64(value)) if big_endian else ctypes.c_uint64(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_float32(self, address: int, value: float | int) -> float:
+    def write_float32(self, address: int, value: float | int, big_endian: bool = False) -> float:
         """Write 4 byte floating-point digit value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_float(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_float(value)) if big_endian else ctypes.c_float(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_float64(self, address: int, value: float | int) -> float:
+    def write_float64(self, address: int, value: float | int, big_endian: bool = False) -> float:
         """Write 8 byte floating-point digit value at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := ctypes.c_double(value)), ctypes.sizeof(buffer), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, ctypes.byref(buffer := __get_be_buffer(ctypes.c_double(value)) if big_endian else ctypes.c_double(value)), ctypes.sizeof(buffer), None)):
             raise Exception("NtWriteVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
-    def write_bytes(self, address: int, value: bytes) -> None:
+    def write_bytes(self, address: int, value: bytes, big_endian: bool = False) -> None:
         """Write bytes array of variadic size at given address."""
 
         # If result failed
-        if (result := _nt_write_virtual_memory(self.handle, address, value, len(value), None)):
+        if (result := _nt_write_virtual_memory(self.handle, address, value[::-1] if big_endian else value, len(value), None)):
             raise Exception("NtReadVirtualMemory failed with status: 0x%s" % hex(result)[2:].upper())
 
     def write_buffer(self, address: int, buffer: typing.Any) -> None: