PyMemoryEditor 1.5.8__tar.gz → 1.5.9__tar.gz

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/.github/workflows/python-package.yml

@@ -34,7 +34,7 @@ jobs:
         pip install -r requirements.txt
     - name: Test with pytest
       run: |
-        pytest tests -v -s
+        pytest tests -v -s -x
     - name: Install package
       run: |
         pip install PyMemoryEditor

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyMemoryEditor
-Version: 1.5.8
+Version: 1.5.9
 Summary: Multi-platform library developed with ctypes for reading, writing and searching process memory, in a simple and friendly way with Python 3.
 Project-URL: Homepage, https://github.com/JeanExtreme002/PyMemoryEditor
 Author-email: Jean Loui Bernard Silva de Jesus <jeanextreme002@gmail.com>
@@ -47,6 +47,9 @@ reading and writing values in the process memory.
 pip3 install PyMemoryEditor
 ```
 
+### Tkinter application sample:
+You can run a simple tkinter application to scan the memory of a process by typing `pymemoryeditor` at the CLI.
+
 # Basic Usage:
 Import `PyMemoryEditor` and open a process using the `OpenProcess` class, passing a window title, process name <br>
 or PID as an argument. You can use the context manager to do this.
@@ -103,13 +106,21 @@ All methods described above work even for strings, including the method `search_
 ## Progress information on searching:
 These methods has the `progress_information` parameter that returns a dictionary containing the search progress information.
 ```py
-for address, info process.search_by_value(..., progress_information = True):
+for address, info in process.search_by_value(..., progress_information = True):
     template = "Address: 0x{:<10X} | Progress: {:.1f}%"
     progress = info["progress"] * 100
     
     print(template.format(address, progress))
 ```
 
+# Reading multiple addresses efficiently:
+If you have a large number of addresses where their values need to be read from memory, using the `search_by_addresses` method is much more efficient than reading the value of each address one by one.
+```py
+for address, value in process.search_by_addresses(int, 4, addresses_list):
+    print(f"Address", address, "holds the value", value)
+```
+The key advantage of this method is that it reads a memory page just once, obtaining the values of the addresses within the page. This approach reduces the frequency of system calls.
+
 ## Getting memory regions:
 Use the method `get_memory_regions()` to get the base address, size and more information of all memory regions used by the process.
 
@@ -119,6 +130,3 @@ for memory_region in process.get_memory_regions():
     size = memory_region["size"]
     information = memory_region["struct"]
 ```
-
-# Tkinter application sample:
-You can run a simple tkinter application to scan the memory of a process by typing `pymemoryeditor` at the CLI.

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/__init__.py

@@ -8,7 +8,7 @@ The package supports Windows and Linux (32-bit and 64-bit).
 """
 
 __author__ = "Jean Loui Bernard Silva de Jesus"
-__version__ = "1.5.8"
+__version__ = "1.5.9"
 
 
 from .enums import ScanTypesEnum

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/linux/functions.py

@@ -7,10 +7,10 @@
 # https://man7.org/linux/man-pages/man5/proc.5.html
 
 from ctypes import addressof, sizeof
-from typing import Generator, Tuple, Type, TypeVar, Union
+from typing import Dict, Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 from ..enums import ScanTypesEnum
-from ..util import get_c_type_of, scan_memory, scan_memory_for_exact_value
+from ..util import convert_from_bytearray, get_c_type_of, scan_memory, scan_memory_for_exact_value
 from .ptrace import libc
 from .types import MEMORY_BASIC_INFORMATION, iovec
 
@@ -67,10 +67,10 @@ def read_process_memory(
         pid, (iovec * 1)(iovec(addressof(data), sizeof(data))),
         1, (iovec * 1)(iovec(address, sizeof(data))), 1, 0
     )
-    return str(data.value) if pytype is str else data.value
+    return data.value.decode() if pytype is str else data.value
 
 
-def search_all_memory(
+def search_addresses_by_value(
     pid: int,
     pytype: Type[T],
     bufflength: int,
@@ -147,6 +147,70 @@ def search_all_memory(
         checked_memory_size += size
 
 
+def search_values_by_addresses(
+    pid: int,
+    pytype: Type[T],
+    bufflength: int,
+    addresses: Sequence[int],
+    *,
+    memory_regions: Optional[Sequence[Dict]] = None,
+    raise_error: bool = False,
+) -> Generator[Tuple[int, Optional[T]], None, None]:
+    """
+    Search the whole memory space, accessible to the process,
+    for the provided list of addresses, returning their values.
+    """
+    if pytype not in [bool, int, float, str, bytes]:
+        raise ValueError("The type must be bool, int, float, str or bytes.")
+
+    memory_regions = list(memory_regions) if memory_regions else list()
+    addresses = sorted(addresses)
+
+    # If no memory page has been given, get all readable memory pages.
+    if not memory_regions:
+        for region in get_memory_regions(pid):
+            if not b"r" in region["struct"].Privileges: continue
+            memory_regions.append(region)
+
+    memory_regions.sort(key=lambda region: region["address"])
+    address_index = 0
+
+    # Walk by each memory region.
+    for region in memory_regions:
+        if address_index >= len(addresses): continue
+
+        target_address = addresses[address_index]
+
+        # Check if the memory region contains the target address.
+        base_address, size = region["address"], region["size"]
+        if not (base_address <= target_address < base_address + size): continue
+
+        region_data = (ctypes.c_byte * size)()
+
+        # Get data from the region.
+        libc.process_vm_readv(
+            pid, (iovec * 1)(iovec(addressof(region_data), sizeof(region_data))),
+            1, (iovec * 1)(iovec(base_address, sizeof(region_data))), 1, 0
+        )
+
+        # Get the value of each address.
+        while base_address <= target_address < base_address + size:
+            offset = target_address - base_address
+            address_index += 1
+
+            try:
+                data = region_data[offset: offset + bufflength]
+                data = (ctypes.c_byte * bufflength)(*data)
+                yield target_address, convert_from_bytearray(data, pytype, bufflength)
+
+            except Exception as error:
+                if raise_error: raise error
+                yield target_address, None
+
+            if address_index >= len(addresses): break
+            target_address = addresses[address_index]
+
+
 def write_process_memory(
     pid: int,
     address: int,

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/linux/process.py

@@ -3,8 +3,14 @@
 from ..enums import ScanTypesEnum
 from ..errors import ClosedProcess
 from ..process import AbstractProcess
-from .functions import get_memory_regions, read_process_memory, search_all_memory, write_process_memory
-from typing import Generator, Optional, Tuple, Type, TypeVar, Union
+from .functions import (
+    get_memory_regions,
+    read_process_memory,
+    search_addresses_by_value,
+    search_values_by_addresses,
+    write_process_memory
+)
+from typing import Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 
 T = TypeVar("T")
@@ -68,6 +74,21 @@ class LinuxProcess(AbstractProcess):
 
         return read_process_memory(self.pid, address, pytype, bufflength)
 
+    def search_by_addresses(
+        self,
+        pytype: Type[T],
+        bufflength: int,
+        addresses: Sequence[int],
+        *,
+        raise_error: bool = False,
+    ) -> Generator[Tuple[int, Optional[T]], None, None]:
+        """
+        Search the whole memory space, accessible to the process,
+        for the provided list of addresses, returning their values.
+        """
+        if self.__closed: raise ClosedProcess()
+        return search_values_by_addresses(self.pid, pytype, bufflength, addresses, raise_error=raise_error)
+
     def search_by_value(
         self,
         pytype: Type[T],
@@ -94,7 +115,7 @@ class LinuxProcess(AbstractProcess):
         if scan_type in [ScanTypesEnum.VALUE_BETWEEN, ScanTypesEnum.NOT_VALUE_BETWEEN]:
             raise ValueError("Use the method search_by_value_between(...) to search within a range of values.")
 
-        return search_all_memory(self.pid, pytype, bufflength, value, scan_type, progress_information, writeable_only)
+        return search_addresses_by_value(self.pid, pytype, bufflength, value, scan_type, progress_information, writeable_only)
 
     def search_by_value_between(
         self,
@@ -122,7 +143,7 @@ class LinuxProcess(AbstractProcess):
         if self.__closed: raise ClosedProcess()
 
         scan_type = ScanTypesEnum.NOT_VALUE_BETWEEN if not_between else ScanTypesEnum.VALUE_BETWEEN
-        return search_all_memory(self.pid, pytype, bufflength, (start, end), scan_type, progress_information, writeable_only)
+        return search_addresses_by_value(self.pid, pytype, bufflength, (start, end), scan_type, progress_information, writeable_only)
 
     def write_process_memory(
         self,

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/process/__init__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 from abc import ABC, abstractmethod
-from typing import Generator, Optional, Tuple, Type, TypeVar, Union
+from typing import Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 from ..enums import ScanTypesEnum
 from ..process.info import ProcessInfo
@@ -61,6 +61,21 @@ class AbstractProcess(ABC):
         """
         raise NotImplementedError()
 
+    @abstractmethod
+    def search_by_addresses(
+        self,
+        pytype: Type[T],
+        bufflength: int,
+        addresses: Sequence[int],
+        *,
+        raise_error: bool = False,
+    ) -> Generator[Tuple[int, Optional[T]], None, None]:
+        """
+        Search the whole memory space, accessible to the process,
+        for the provided list of addresses, returning their values.
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def search_by_value(
         self,

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/sample/main_application_window.py

@@ -21,7 +21,6 @@ class ApplicationWindow(Tk):
         self.__process = process
 
         self.__scan_type = ScanTypesEnum.EXACT_VALUE
-        self.__value = 0
         self.__value_type = int
         self.__value_length = 4
         self.__addresses = []
@@ -211,9 +210,7 @@ class ApplicationWindow(Tk):
 
         # Start the scan.
         value = pytype(value)
-
         self.__value_length = length
-        self.__value = value
 
         self.after(100, lambda: self.__start_scan(pytype, length, value, scan_type))
 
@@ -288,7 +285,7 @@ class ApplicationWindow(Tk):
             if self.__close: break
 
             self.__address_list.insert("end", f"Addr: {hex(address)[2:].upper()}")
-            self.__value_list.insert("end", f"Value: {value}")
+            self.__value_list.insert("end", f"Value: loading...")
 
             self.__progress_var.set(info["progress"] * 100)
             self.__addresses.append(address)
@@ -296,6 +293,8 @@ class ApplicationWindow(Tk):
 
             self.__count_label.config(text=f"Found {len(self.__addresses)} addresses.")
 
+        self.__update_values()
+
         self.__new_scan_button.config(text="New Scan")
         self.__next_scan_button.config(text="Next Scan")
         self.__progress_var.set(100)
@@ -344,73 +343,67 @@ class ApplicationWindow(Tk):
             if char not in "0123456789ABCDEF": return False
         return True
 
-    def __update_values(self, index = 0, *, remove = False, first_call = True):
+    def __update_values(self, *, remove: bool = False):
         """
         Update the values of the found addresses. If "remove" is True, it will
         compare the current value in memory and remove the address from the
         results if the comparison is False.
         """
-        if self.__updating and first_call: return  # Allow call the method once.
+        if self.__updating: return
 
-        # Return if user asked for closing the application.
-        if self.__close:
-            self.__updating = False
-            return
+        if not self.__addresses: return self.__progress_var.set(100)
 
         # Get the value to compare.
-        if first_call:
-            value = self.__value_entry.get().strip()
+        value = self.__value_entry.get().strip()
+        total = len(self.__addresses)
 
-            try:
-                if str(self.__value_type(value)) != value:
-                    raise ValueError()
-            except:
-                self.__value_entry.delete(0, "end")
-                return self.__value_entry.insert(0, "Invalid value")
+        try:
+            if str(self.__value_type(value)) != value:
+                raise ValueError()
+        except:
+            self.__value_entry.delete(0, "end")
+            return self.__value_entry.insert(0, "Invalid value")
 
-            self.__value = self.__value_type(value)
-            self.__progress_var.set(0)
+        self.__value = self.__value_type(value)
+        self.__progress_var.set(0)
 
         # Indicate the application is updating the values.
         self.__updating = True
 
-        if index % 10 == 0: self.update()
+        new_scan_button_text = self.__new_scan_button["text"]
+        self.__new_scan_button.config(text="Updating")
 
-        # Get the address from the list.
-        try:
-            address = self.__addresses[index]
-        except:
-            self.__updating = False
-
-            self.__count_label.config(text=f"Found {len(self.__addresses)} addresses.")
-            return self.__progress_var.set(100 if not first_call else 0)
+        # Get the address and its current value in memory.
+        total, count = len(self.__addresses), 0
 
-        # Get the current value of the address.
-        corrupted = False
-        value = None
+        for address, value in self.__process.search_by_addresses(self.__value_type, self.__value_length, self.__addresses):
+            self.__progress_var.set((count / total) * 100)
+            self.update()
 
-        try: value = self.__process.read_process_memory(address, self.__value_type, self.__value_length)
-        except: corrupted = True
+            index = self.__addresses.index(address)
+            count += 1
 
-        # If "remove" is True, compare the value.
-        if remove or corrupted:
-            compare = self.__comp_methods[self.__scan_type]
+            # Return if user asked for closing the application.
+            if self.__close:
+                self.__updating = False
+                return
 
-            # Remove the address from the results.
-            if corrupted or not compare(value, self.__value):
+            # If value is corrupted or "remove" is True and comparison is False, remove the value from the results.
+            if value is None or (remove and not self.__comp_methods[self.__scan_type](value, self.__value)):
                 self.__address_list.delete(index)
                 self.__value_list.delete(index)
                 self.__addresses.remove(address)
-                index -= 1
 
-        # Update the value at the listbox.
-        else:
-            self.__value_list.delete(index)
-            self.__value_list.insert(index, f"Value: {value}")
+            # Update the value at the listbox.
+            else:
+                self.__value_list.delete(index)
+                self.__value_list.insert(index, f"Value: {value}")
+
+        self.__new_scan_button.config(text=new_scan_button_text)
+        self.__updating = False
 
-        # Call the method again recursively
-        if index % 10 == 0: self.__progress_var.set((index / len(self.__addresses)) * 100)
-        self.after(5, lambda: self.__update_values(index + 1, remove=remove, first_call=False))
+        self.__count_label.config(text=f"Found {len(self.__addresses)} addresses.")
+        self.__progress_var.set(100)
 
     def __write_value(self):
         """

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/util/__init__.py

@@ -1,10 +1,25 @@
 # -*- coding: utf-8 -*-
 
 from .scan import scan_memory, scan_memory_for_exact_value
-from typing import Type
+from typing import Type, TypeVar
 import ctypes
 
 
+T = TypeVar("T")
+
+
+def convert_from_bytearray(bytearray: ctypes.Array, pytype: Type[T], length: int = 1) -> T:
+    """
+    Convert a byte array to a Python type.
+    """
+    if pytype is bytes: return bytes(bytearray)
+    if pytype is str: return bytes(bytearray).decode()
+
+    c_value = get_c_type_of(pytype, length)
+
+    return c_value.__class__.from_buffer(bytearray).value
+
+
 def get_c_type_of(pytype: Type, length: int = 1) -> ctypes._SimpleCData:
     """
     Return a C type of a primitive type of the Python language.

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/win32/functions.py

@@ -7,12 +7,12 @@
 # ...
 
 from ..enums import ScanTypesEnum
-from ..util import get_c_type_of, scan_memory, scan_memory_for_exact_value
+from ..util import convert_from_bytearray, get_c_type_of, scan_memory, scan_memory_for_exact_value
 
 from .enums import MemoryAllocationStatesEnum, MemoryProtectionsEnum, MemoryTypesEnum
 from .types import MEMORY_BASIC_INFORMATION, SYSTEM_INFO, WNDENUMPROC
 
-from typing import Generator, Tuple, Type, TypeVar, Union
+from typing import Dict, Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 import ctypes
 import ctypes.wintypes
@@ -130,7 +130,7 @@ def ReadProcessMemory(
     return data.value.decode() if pytype is str else data.value
 
 
-def SearchAllMemory(
+def SearchAddressesByValue(
     process_handle: int,
     pytype: Type[T],
     bufflength: int,
@@ -163,7 +163,7 @@ def SearchAllMemory(
     # Get the memory regions, computing the total amount of memory to be scanned.
     checked_memory_size = 0
     memory_total = 0
-    regions = list()
+    memory_regions = list()
 
     for region in GetMemoryRegions(process_handle):
 
@@ -176,10 +176,10 @@ def SearchAllMemory(
         if writeable_only and region["struct"].Protect & MemoryProtectionsEnum.PAGE_READWRITEABLE.value == 0: continue
 
         memory_total += region["size"]
-        regions.append(region)
+        memory_regions.append(region)
 
     # Check each memory region used by the process.
-    for region in regions:
+    for region in memory_regions:
         address, size = region["address"], region["size"]
         region_data = (ctypes.c_byte * size)()
 
@@ -206,6 +206,70 @@ def SearchAllMemory(
         checked_memory_size += size
 
 
+def SearchValuesByAddresses(
+    process_handle: int,
+    pytype: Type[T],
+    bufflength: int,
+    addresses: Sequence[int],
+    *,
+    memory_regions: Optional[Sequence[Dict]] = None,
+    raise_error: bool = False,
+) -> Generator[Tuple[int, Optional[T]], None, None]:
+    """
+    Search the whole memory space, accessible to the process,
+    for the provided list of addresses, returning their values.
+    """
+    if pytype not in [bool, int, float, str, bytes]:
+        raise ValueError("The type must be bool, int, float, str or bytes.")
+
+    memory_regions = list(memory_regions) if memory_regions else list()
+    addresses = sorted(addresses)
+
+    # If no memory page has been given, get all committed, non-shared and readable memory pages.
+    if not memory_regions:
+        for region in GetMemoryRegions(process_handle):
+            if region["struct"].State != MemoryAllocationStatesEnum.MEM_COMMIT.value: continue
+            if region["struct"].Type != MemoryTypesEnum.MEM_PRIVATE.value: continue
+            if region["struct"].Protect & MemoryProtectionsEnum.PAGE_READABLE.value == 0: continue
+
+            memory_regions.append(region)
+
+    memory_regions.sort(key=lambda region: region["address"])
+    address_index = 0
+
+    # Walk by each memory region.
+    for region in memory_regions:
+        if address_index >= len(addresses): continue
+
+        target_address = addresses[address_index]
+
+        # Check if the memory region contains the target address.
+        base_address, size = region["address"], region["size"]
+        if not (base_address <= target_address < base_address + size): continue
+
+        region_data = (ctypes.c_byte * size)()
+
+        # Get data from the region.
+        kernel32.ReadProcessMemory(process_handle, ctypes.c_void_p(base_address), ctypes.byref(region_data), size, None)
+
+        # Get the value of each address.
+        while base_address <= target_address < base_address + size:
+            offset = target_address - base_address
+            address_index += 1
+
+            try:
+                data = region_data[offset: offset + bufflength]
+                data = (ctypes.c_byte * bufflength)(*data)
+                yield target_address, convert_from_bytearray(data, pytype, bufflength)
+
+            except Exception as error:
+                if raise_error: raise error
+                yield target_address, None
+
+            if address_index >= len(addresses): break
+            target_address = addresses[address_index]
+
+
 def WriteProcessMemory(
     process_handle: int,
     address: int,

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/PyMemoryEditor/win32/process.py

@@ -10,11 +10,12 @@ from .functions import (
     GetMemoryRegions,
     GetProcessHandle,
     ReadProcessMemory,
-    SearchAllMemory,
+    SearchAddressesByValue,
+    SearchValuesByAddresses,
     WriteProcessMemory
 )
 
-from typing import Generator, Optional, Tuple, Type, TypeVar, Union
+from typing import Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 
 T = TypeVar("T")
@@ -70,6 +71,29 @@ class WindowsProcess(AbstractProcess):
 
         return GetMemoryRegions(self.__process_handle)
 
+    def search_by_addresses(
+        self,
+        pytype: Type[T],
+        bufflength: int,
+        addresses: Sequence[int],
+        *,
+        raise_error: bool = False,
+    ) -> Generator[Tuple[int, Optional[T]], None, None]:
+        """
+        Search the whole memory space, accessible to the process,
+        for the provided list of addresses, returning their values.
+        """
+        if self.__closed: raise ClosedProcess()
+
+        valid_permissions = [
+            ProcessOperationsEnum.PROCESS_ALL_ACCESS.value,
+            ProcessOperationsEnum.PROCESS_VM_READ.value
+        ]
+        if self.__permission.value not in valid_permissions:
+            raise PermissionError("The handle does not have permission to read the process memory.")
+
+        return SearchValuesByAddresses(self.__process_handle, pytype, bufflength, addresses, raise_error=raise_error)
+
     def search_by_value(
         self,
         pytype: Type[T],
@@ -103,7 +127,7 @@ class WindowsProcess(AbstractProcess):
         if scan_type in [ScanTypesEnum.VALUE_BETWEEN, ScanTypesEnum.NOT_VALUE_BETWEEN]:
             raise ValueError("Use the method search_by_value_between(...) to search within a range of values.")
 
-        return SearchAllMemory(self.__process_handle, pytype, bufflength, value, scan_type, progress_information, writeable_only)
+        return SearchAddressesByValue(self.__process_handle, pytype, bufflength, value, scan_type, progress_information, writeable_only)
 
     def search_by_value_between(
         self,
@@ -138,7 +162,7 @@ class WindowsProcess(AbstractProcess):
             raise PermissionError("The handle does not have permission to read the process memory.")
 
         scan_type = ScanTypesEnum.NOT_VALUE_BETWEEN if not_between else ScanTypesEnum.VALUE_BETWEEN
-        return SearchAllMemory(self.__process_handle, pytype, bufflength, (start, end), scan_type, progress_information, writeable_only)
+        return SearchAddressesByValue(self.__process_handle, pytype, bufflength, (start, end), scan_type, progress_information, writeable_only)
 
     def read_process_memory(
         self,

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/README.md

@@ -15,6 +15,9 @@ reading and writing values in the process memory.
 pip3 install PyMemoryEditor
 ```
 
+### Tkinter application sample:
+You can run a simple tkinter application to scan the memory of a process by typing `pymemoryeditor` at the CLI.
+
 # Basic Usage:
 Import `PyMemoryEditor` and open a process using the `OpenProcess` class, passing a window title, process name <br>
 or PID as an argument. You can use the context manager to do this.
@@ -71,13 +74,21 @@ All methods described above work even for strings, including the method `search_
 ## Progress information on searching:
 These methods has the `progress_information` parameter that returns a dictionary containing the search progress information.
 ```py
-for address, info process.search_by_value(..., progress_information = True):
+for address, info in process.search_by_value(..., progress_information = True):
     template = "Address: 0x{:<10X} | Progress: {:.1f}%"
     progress = info["progress"] * 100
     
     print(template.format(address, progress))
 ```
 
+# Reading multiple addresses efficiently:
+If you have a large number of addresses where their values need to be read from memory, using the `search_by_addresses` method is much more efficient than reading the value of each address one by one.
+```py
+for address, value in process.search_by_addresses(int, 4, addresses_list):
+    print(f"Address", address, "holds the value", value)
+```
+The key advantage of this method is that it reads a memory page just once, obtaining the values of the addresses within the page. This approach reduces the frequency of system calls.
+
 ## Getting memory regions:
 Use the method `get_memory_regions()` to get the base address, size and more information of all memory regions used by the process.
 
@@ -87,6 +98,3 @@ for memory_region in process.get_memory_regions():
     size = memory_region["size"]
     information = memory_region["struct"]
 ```
-
-# Tkinter application sample:
-You can run a simple tkinter application to scan the memory of a process by typing `pymemoryeditor` at the CLI.

{pymemoryeditor-1.5.8 → pymemoryeditor-1.5.9}/tests/test_editor.py

@@ -68,13 +68,15 @@ def test_read_int():
 
 def test_read_string():
     # Get a random text to compare the result.
-    target_value = ctypes.create_string_buffer(generate_text(20).encode())
+    target_value = ctypes.create_string_buffer(20)
+    target_value.value = generate_text(20).encode()
+
     address = ctypes.addressof(target_value)
     data_length = ctypes.sizeof(target_value)
 
     # Read the process memory and compare the result.
     result = process.read_process_memory(address, str, data_length)
-    assert type(result) is str and result == str(target_value.value)
+    assert type(result) is str and result == target_value.value.decode()
 
 
 def test_write_bool():
@@ -134,20 +136,69 @@ def test_write_string():
     original_value = generate_text(20).encode()
     new_value = generate_text(20).encode()
 
-    target_value = ctypes.create_string_buffer(original_value)
+    target_value = ctypes.create_string_buffer(20)
+    target_value.value = original_value
+
     address = ctypes.addressof(target_value)
     data_length = ctypes.sizeof(target_value)
 
     # Write to the process memory and compare the result.
-    process.write_process_memory(address, str, data_length, new_value)
+    process.write_process_memory(address, str, data_length, new_value.decode())
     assert target_value.value != original_value and target_value.value == new_value
 
 
+def test_search_by_int_addresses():
+    # Get random values to compare the result.
+    test_length = 10
+
+    target_values = [ctypes.c_int(random.randint(0, 10000)) for i in range(test_length)]
+    data_length = ctypes.sizeof(target_values[0])
+
+    target_values = {ctypes.addressof(v): v for v in target_values}
+    addresses = list(target_values.keys())
+
+    for address, value in process.search_by_addresses(int, data_length, addresses):
+        assert target_values[address].value == value and type(value) is int
+
+def test_search_by_float_addresses():
+    # Get random values to compare the result.
+    test_length = 10
+
+    target_values = [ctypes.c_double(random.randint(0, 10000) / random.randint(0, 10000)) for i in range(test_length)]
+    data_length = ctypes.sizeof(target_values[0])
+
+    target_values = {ctypes.addressof(v): v for v in target_values}
+    addresses = list(target_values.keys())
+
+    for address, value in process.search_by_addresses(float, data_length, addresses):
+        assert target_values[address].value == value and type(value) is float
+
+
+def test_search_by_string_addresses():
+    # Get random values to compare the result.
+    string_length, test_length = 20, 10
+
+    target_values = list()
+
+    for i in range(test_length):
+        value = ctypes.create_string_buffer(string_length)
+        value.value = generate_text(string_length).encode()
+        target_values.append(value)
+
+    data_length = ctypes.sizeof(target_values[0])
+
+    target_values = {ctypes.addressof(v): v for v in target_values}
+    addresses = list(target_values.keys())
+
+    for address, value in process.search_by_addresses(str, data_length, addresses):
+        assert target_values[address].value.decode() == value and type(value) is str
+
+
 def test_search_by_int():
     # Get random values to compare the result.
-    length = 10
+    test_length = 10
 
-    target_values = [ctypes.c_int(random.randint(0, 10000)) for i in range(length)]
+    target_values = [ctypes.c_int(random.randint(0, 10000)) for i in range(test_length)]
     addresses = [ctypes.addressof(v) for v in target_values]
     data_length = ctypes.sizeof(target_values[0])
 
@@ -172,15 +223,15 @@ def test_search_by_int():
         value = process.read_process_memory(found_address, int, data_length)
         if min_value <= value <= max_value: correct += 1
 
-    assert found / length >= 0.7
+    assert found / test_length >= 0.7
     assert correct / total >= 0.7  # Some of the addresses are beyond our control and may have their values changed.
 
 
 def test_search_by_float():
     # Get random values to compare the result.
-    length = 10
+    test_length = 10
 
-    target_values = [ctypes.c_double(random.randint(0, 10000)) for i in range(length)]
+    target_values = [ctypes.c_double(random.randint(0, 10000)) for i in range(test_length)]
     addresses = [ctypes.addressof(v) for v in target_values]
     data_length = ctypes.sizeof(target_values[0])
 
@@ -205,15 +256,21 @@ def test_search_by_float():
         value = process.read_process_memory(found_address, float, data_length)
         if min_value <= value <= max_value: correct += 1
 
-    assert found / length >= 0.7
+    assert found / test_length >= 0.7
     assert correct / total >= 0.7  # Some of the addresses are beyond our control and may have their values changed.
 
 
 def test_search_by_string():
     # Get random values to compare the result.
-    length = 10
+    string_length, test_length = 20, 10
+
+    target_values = list()
+
+    for i in range(test_length):
+        value = ctypes.create_string_buffer(string_length)
+        value.value = generate_text(string_length).encode()
+        target_values.append(value)
 
-    target_values = [ctypes.create_string_buffer(generate_text(20).encode()) for i in range(length)]
     data_length = ctypes.sizeof(target_values[0])
 
     total = 0
@@ -231,22 +288,30 @@ def test_search_by_string():
             total += 1
 
             # Check if the address really points to a valid value.
-            value = process.read_process_memory(found_address, str, data_length)
-            if value == str(target_value.value): correct += 1
+            try:
+                value = process.read_process_memory(found_address, str, data_length)
+                if value == target_value.value.decode(): correct += 1
+            except: pass
 
-    assert found / length >= 0.7
+    assert found / test_length >= 0.7
     assert correct / total >= 0.7  # Some of the addresses are beyond our control and may have their values changed.
 
 
 def test_search_by_string_between():
     # Get random values to compare the result.
-    length = 10
+    string_length, test_length = 20, 10
+
+    values = list()
+
+    for i in range(test_length * 2):
+        value = ctypes.create_string_buffer(string_length)
+        value.value = generate_text(string_length).encode()
+        values.append(value)
 
-    values = [ctypes.create_string_buffer(generate_text(20).encode()) for i in range(length * 2)]
     values.sort(key = lambda target_value: target_value.value)
 
     # Half of the set of strings is the target and the other half contains string that should be ignored by the scanner.
-    target_values = [target_value for target_value in values[length // 4: length - length // 4]]
+    target_values = [target_value for target_value in values[test_length // 4: test_length - test_length // 4]]
 
     addresses = [ctypes.addressof(v) for v in values]
     target_addresses = [ctypes.addressof(v) for v in target_values]
@@ -269,7 +334,7 @@ def test_search_by_string_between():
         elif found_address in addresses:
             raise ValueError("Scanner returned the address of a clearly invalid string.")
 
-    assert found / length >= 0.5
+    assert found / test_length >= 0.5
 
 
 def test_close_process():