PyMemoryEditor 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

PyMemoryEditor/__init__.py

@@ -8,7 +8,7 @@ Supported platforms: Windows, Linux and macOS (32-bit and 64-bit).
 """
 
 __author__ = "Jean Loui Bernard Silva de Jesus"
-__version__ = "3.1.0"
+__version__ = "3.2.0"
 
 import logging
 import sys

PyMemoryEditor/app/_widgets.py

@@ -6,9 +6,10 @@ Centralises tiny helpers (numeric sort items, hex address parsing) that
 previously appeared duplicated across several dialog modules.
 """
 
+import threading
 from typing import Any, Callable, Iterable, List, Optional, Tuple
 
-from PySide6.QtCore import QObject, Qt, QThread
+from PySide6.QtCore import QCoreApplication, QObject, Qt, QThread, QTimer
 from PySide6.QtGui import QStandardItem
 
 
@@ -84,6 +85,56 @@ def _reap_detached_worker(worker: QThread) -> None:
     worker.deleteLater()
 
 
+def detached_workers_running() -> bool:
+    """Whether any worker that outlived its owner is still running."""
+    return any(worker.isRunning() for worker in _DETACHED_WORKERS)
+
+
+def run_after_detached_workers(callback: Callable[[], None]) -> None:
+    """Run ``callback`` once every currently detached worker has finished.
+
+    A detached worker can still be inside a backend syscall on the process it
+    was given, so releasing that process (``close()``) must wait for it: on
+    Windows the handle value can be recycled for an unrelated object the moment
+    it is closed, and a late write from the cheat poller would land there.
+    With no worker still running, ``callback`` runs immediately.
+    """
+    pending = [worker for worker in _DETACHED_WORKERS if worker.isRunning()]
+    if not pending:
+        callback()
+        return
+
+    remaining = set(pending)
+    done = False
+    # `finished` can be delivered from the worker's own thread while the
+    # isFinished() sweep below runs on this one: guard the bookkeeping so the
+    # callback (a handle close) runs exactly once.
+    guard = threading.Lock()
+    # Whichever thread notices the last worker finishing, the callback is
+    # posted to the GUI thread (the application object lives there), so it
+    # never runs concurrently with the GUI setting up the next process.
+    gui = QCoreApplication.instance()
+
+    def _on_finished(worker: QThread) -> None:
+        nonlocal done
+        with guard:
+            remaining.discard(worker)
+            if remaining or done:
+                return
+            done = True
+        if gui is None:
+            callback()
+        else:
+            QTimer.singleShot(0, gui, callback)
+
+    for worker in pending:
+        worker.finished.connect(lambda w=worker: _on_finished(w))
+    # Same race as detach_worker: one may have finished before its connect.
+    for worker in pending:
+        if worker.isFinished():
+            _on_finished(worker)
+
+
 class TearsDownOnClose:
     """Mixin that runs a dialog's teardown on *every* way out, not just close.
 

PyMemoryEditor/app/application.py

@@ -561,6 +561,7 @@ def main(argv=None):
     from PySide6.QtCore import QSettings
     from PySide6.QtWidgets import QApplication
 
+    from ._widgets import detached_workers_running
     from .main_window import MainWindow
     from .open_process_dialog import OpenProcessDialog
 
@@ -591,12 +592,18 @@ def main(argv=None):
         with _scoped_excepthook(_qt_excepthook):
             app.exec()
     finally:
-        try:
-            # `process` is only the handle the picker opened; File → Change
-            # Process… released that one and attached the window to another.
-            window.process.close()
-        except Exception:
-            pass
+        # A worker that blew its join on close is detached, not stopped, and
+        # may still be inside a syscall on this handle; closing it now could
+        # hand its value to an unrelated object mid-write. The process is
+        # exiting, so leave it to the OS, which releases every handle then.
+        if not detached_workers_running():
+            try:
+                # `process` is only the handle the picker opened; File →
+                # Change Process… released that one and attached the window
+                # to another.
+                window.process.close()
+            except Exception:
+                pass
 
 
 def main_cli(argv=None):

PyMemoryEditor/app/main_window.py

@@ -46,7 +46,7 @@ from PySide6.QtWidgets import (
 from PyMemoryEditor import AbstractProcess, __version__
 
 from ._icon import app_icon
-from ._widgets import detach_worker
+from ._widgets import detach_worker, run_after_detached_workers
 from .application import DEFAULT_THEME_ID, THEMES, apply_theme
 from .cheat_entry import CheatEntry
 from .cheat_table import CheatTable
@@ -910,13 +910,11 @@ class MainWindow(QMainWindow):
             old_cheat.shutdown()
         except Exception:
             pass
-        # Accepted window: a worker that blew its join is detached, not
-        # stopped, so it can still be inside a syscall here. The cheat poller
-        # writes, which is why it checks the stop flag per entry.
-        try:
-            old_process.close()
-        except Exception:
-            pass
+        # A worker that blew its join is detached, not stopped, so it can still
+        # be inside a syscall on the old handle. Release the handle only once
+        # every detached worker has finished; closing it now could hand its
+        # value to an unrelated object while the cheat poller is mid-write.
+        run_after_detached_workers(lambda p=old_process: _close_quietly(p))
         old_index = self._right_splitter.indexOf(old_cheat)
         self._cheat = CheatTable(self._process)
         self._cheat.pointer_scan_for_address.connect(self._open_pointer_scan_dialog)
@@ -1049,6 +1047,13 @@ class MainWindow(QMainWindow):
             worker.deleteLater()
 
 
+def _close_quietly(process) -> None:
+    try:
+        process.close()
+    except Exception:  # noqa: BLE001 — the target may already be gone
+        pass
+
+
 def _safe_for_json(value) -> object:
     if value is None or isinstance(value, (str, int, float, bool)):
         return value

PyMemoryEditor/app/pointer_scan_dialog.py

@@ -50,7 +50,10 @@ from PySide6.QtWidgets import (
 )
 
 from PyMemoryEditor import AbstractProcess, PointerPath
-from PyMemoryEditor.process.pointer_scan import intersect_pointer_paths
+from PyMemoryEditor.process.pointer_scan import (
+    first_module_bases,
+    intersect_pointer_paths,
+)
 
 from ._widgets import (
     MONOSPACE_FAMILY,
@@ -141,6 +144,9 @@ class PointerScanWorker(QThread):
                 writable_only=req.writable_only,
                 max_results=req.max_results,
                 progress_callback=self._on_map_progress,
+                # The walk can run a long time between two paths; this lets
+                # Stop end it there too, not only at the next yield.
+                should_stop=lambda: self._cancelled,
             )
 
             batch: List[_ResultRow] = []
@@ -246,7 +252,7 @@ class PointerRescanWorker(QThread):
     def run(self) -> None:
         try:
             # One name→base lookup so rebasing each saved path is O(1).
-            module_bases = {m.name: m.base_address for m in self._process.get_modules()}
+            module_bases = first_module_bases(self._process.get_modules())
 
             batch: List[_ResultRow] = []
             total = len(self._paths) or 1
@@ -284,16 +290,8 @@ class PointerRescanWorker(QThread):
     def _rebase(self, saved: PointerPath, module_bases: dict) -> Optional[PointerPath]:
         """Move a saved path onto the live module base, or None if not rebasable."""
         if saved.module is not None and saved.module_offset is not None:
-            base = module_bases.get(saved.module)
-            if base is None:
-                return None  # module not loaded in this run — drop the path
-            return PointerPath(
-                base_address=base + saved.module_offset,
-                offsets=saved.offsets,
-                module=saved.module,
-                module_offset=saved.module_offset,
-                ptr_size=saved.ptr_size,
-            )
+            # None when the module isn't loaded in this run — drop the path.
+            return saved._rebased_onto(module_bases)
         # No module: the absolute base is only a best-effort guess post-restart.
         return saved
 
@@ -979,23 +977,23 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         # For display, rebase each survivor onto the current process and read its
         # value — best effort; a path that can't resolve now is still a valid
         # member of the intersection and is kept (shown dimmed / "—").
-        module_bases = {m.name: m.base_address for m in self._process.get_modules()}
+        unavailable = ""
+        try:
+            module_bases = first_module_bases(self._process.get_modules())
+        except Exception as exc:  # noqa: BLE001 — display only; the target may be gone
+            # Without the module list every survivor is shown unresolved ("—"),
+            # which is what the per-path guard below does for a single one —
+            # but say why, or a table of dimmed rows reads as "nothing works".
+            module_bases = {}
+            unavailable = (
+                f" Values not shown: the target's modules could not be listed "
+                f"({type(exc).__name__}: {exc})."
+            )
         spec, length = self._current_spec()
 
         rows: List[_ResultRow] = []
         for saved in survivors:
-            base = module_bases.get(saved.module)
-            live = (
-                PointerPath(
-                    base_address=base + saved.module_offset,
-                    offsets=saved.offsets,
-                    module=saved.module,
-                    module_offset=saved.module_offset,
-                    ptr_size=saved.ptr_size,
-                )
-                if base is not None and saved.module_offset is not None
-                else saved
-            )
+            live = saved._rebased_onto(module_bases) or saved
             try:
                 resolved = live.resolve(self._process)
                 value = self._process.read_process_memory(resolved, spec.pytype, length)
@@ -1008,6 +1006,7 @@ class PointerScanDialog(TearsDownOnClose, QDialog):
         self._append_rows(rows)
         self._count_label.setText(
             f"{len(survivors):,} path(s) common to {len(filenames)} scans."
+            + unavailable
         )
         self._export_btn.setEnabled(True)
 

PyMemoryEditor/linux/functions.py

@@ -10,6 +10,7 @@ import ctypes
 import errno as errno_mod
 import logging
 import os
+import signal
 from ctypes import addressof, sizeof
 from typing import Dict, Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
@@ -20,6 +21,7 @@ from ..process.region import (
     MemoryRegion,
     default_address_filter,
     default_scan_filter,
+    MemoryRegionSnapshot,
     make_region,
 )
 from ..process.scanning import (
@@ -84,6 +86,11 @@ _PTRACE_SCOPE_HINT = (
 )
 
 
+def _errno_or(exc: OSError, default: int) -> int:
+    """``exc.errno``, or ``default`` when the exception was raised without one."""
+    return exc.errno if exc.errno is not None else default
+
+
 def _syscall_error(op: str, errno: int, remote_address: int, length: int) -> OSError:
     """
     Build the ``OSError`` for a failed ``process_vm_readv`` / ``process_vm_writev``.
@@ -225,10 +232,11 @@ def get_memory_regions(pid: int) -> Generator["MemoryRegion", None, None]:
         # prctl(PR_SET_DUMPABLE, 0)). The ptrace_scope hint belongs to the
         # EPERM from process_vm_readv/writev, not to this path.
         raise PermissionError(
+            _errno_or(exc, errno_mod.EACCES),
             "Cannot read %s: %s. The target process belongs to another user "
             "or is not dumpable; run as root or as the owner of the target."
-            % (mapping_filename, exc)
-        )
+            % (mapping_filename, exc),
+        ) from exc
 
     with mapping_file:
         for line in mapping_file:
@@ -552,7 +560,11 @@ def search_values_by_addresses(
         memory_regions = [
             region for region in get_memory_regions(pid) if default_address_filter(region)
         ]
-    else:
+    elif not isinstance(memory_regions, MemoryRegionSnapshot):
+        # Materialize any other iterable (it is indexed and walked more than
+        # once), but pass a snapshot through untouched: `list(...)` would drop
+        # its type tag and make `_ensure_sorted_by_address` re-sort an
+        # already-sorted region map on every refine scan.
         memory_regions = list(memory_regions)
 
     yield from iter_values_for_addresses(
@@ -615,10 +627,11 @@ def get_threads(pid: int) -> Generator[ThreadInfo, None, None]:
         return
     except PermissionError as exc:
         raise PermissionError(
+            _errno_or(exc, errno_mod.EACCES),
             "Cannot list %s: %s. The target process belongs to another user "
             "or is not dumpable; run as root or as the owner of the target."
-            % (task_dir, exc)
-        )
+            % (task_dir, exc),
+        ) from exc
     except OSError as exc:
         _logger.debug("get_threads: could not list %s: %s", task_dir, exc)
         return
@@ -701,3 +714,97 @@ def process_exists(pid: int) -> bool:
     if pid < 0:
         return False
     return os.path.isdir("/proc/{}".format(pid))
+
+
+# --- Target identity (PID-reuse guard) --------------------------------------
+#
+# Unlike a Windows process handle or a macOS task port, nothing on the Linux
+# path pins the target: process_vm_readv / process_vm_writev and /proc take a
+# bare pid. Once the target exits and is reaped, the kernel may hand that pid
+# to an unrelated process, and every later call would silently act on it. The
+# helpers below let LinuxProcess bind to the *original* process at open time
+# and verify it before touching the target again.
+
+
+def open_pidfd(pid: int) -> Optional[int]:
+    """
+    Return a pidfd for ``pid`` (``pidfd_open(2)``, Linux 5.3+), or ``None``
+    when pidfds are unavailable: the kernel predates them (``ENOSYS``), a
+    seccomp policy blocks the syscall (``EPERM``, e.g. older container
+    runtimes), ``pid`` is a non-leader thread id (``EINVAL``), the fd table is
+    full, or this Python was built without ``os.pidfd_open`` /
+    ``signal.pidfd_send_signal``. Callers then fall back to
+    :func:`read_start_time`.
+
+    Raises :class:`~PyMemoryEditor.ProcessIDNotExistsError` when the process
+    is already gone (``ESRCH``) — it exited after the open-time existence
+    check.
+    """
+    pidfd_open = getattr(os, "pidfd_open", None)
+    if pidfd_open is None or not hasattr(signal, "pidfd_send_signal"):
+        return None
+    try:
+        return pidfd_open(pid, 0)
+    except ProcessLookupError:
+        raise ProcessIDNotExistsError(pid)
+    except OSError as exc:
+        _logger.debug(
+            "open_pidfd: pidfd_open(%d) failed (%s); falling back to the "
+            "/proc start-time check for PID-reuse detection.",
+            pid,
+            exc,
+        )
+        return None
+
+
+def pidfd_alive(pidfd: int) -> Optional[bool]:
+    """
+    Whether the process ``pidfd`` refers to still exists, via a null signal
+    (``pidfd_send_signal(pidfd, 0, NULL, 0)``): one syscall, no side effect.
+
+    The answer is about the original process, not its pid number — after the
+    target is reaped the call fails with ``ESRCH`` even if the pid has already
+    been reused. A zombie still counts as alive (it keeps its pid until it is
+    reaped), matching the ``kill(pid, 0)`` semantics of the base class.
+    ``EPERM`` (target owned by another user) also means "exists". Returns
+    ``None`` when the probe itself cannot answer (e.g. ``EINVAL`` for a
+    target outside this pid namespace), so the caller can fall back.
+    """
+    try:
+        signal.pidfd_send_signal(pidfd, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError as exc:
+        _logger.debug("pidfd_alive: pidfd_send_signal failed: %s", exc)
+        return None
+    return True
+
+
+def read_start_time(pid: int) -> Optional[int]:
+    """
+    Return the process start time (field 22 of ``/proc/<pid>/stat``, in clock
+    ticks since boot), or ``None`` if the file can't be read or parsed (the
+    process is gone, or ``/proc`` is mounted with ``hidepid``).
+
+    ``(pid, start time)`` identifies a process uniquely — a recycled pid gets
+    a later start time — which makes it the PID-reuse guard on kernels
+    without pidfds.
+    """
+    try:
+        with open("/proc/{}/stat".format(pid), "rb") as fh:
+            raw_stat = fh.read()
+    except OSError:
+        return None
+
+    # `comm` is parenthesised and may itself contain spaces or ')': split
+    # after the *last* ')'. rest[0] is field 3 (state), so field 22 is rest[19].
+    close_paren = raw_stat.rfind(b")")
+    if close_paren == -1:
+        return None
+    rest = raw_stat[close_paren + 1 :].split()
+    try:
+        return int(rest[19])
+    except (IndexError, ValueError):
+        return None

PyMemoryEditor/linux/process.py

@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
 
+import logging
+import os
 import warnings
 from typing import Generator, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 from ..enums import ScanTypesEnum
 from ..process import AbstractProcess
-from ..process.errors import ClosedProcess
+from ..process.errors import ClosedProcess, ProcessIDNotExistsError
 from ..util import (
     UNSET,
     prepare_write,
@@ -20,15 +22,22 @@ from .functions import (
     get_memory_regions,
     get_modules,
     get_threads,
+    open_pidfd,
+    pidfd_alive,
+    process_exists,
     read_process_memory,
     read_process_memory_into,
     search_addresses_by_pattern,
     search_addresses_by_value,
     search_values_by_addresses,
+    read_start_time,
     write_process_memory,
 )
 
 
+_logger = logging.getLogger("PyMemoryEditor")
+
+
 T = TypeVar("T")
 
 
@@ -69,6 +78,17 @@ class LinuxProcess(AbstractProcess):
             exact_match=exact_match,
             strict_bitness=strict_bitness,
         )
+
+        # Bind to *this* process, not to its pid number. Linux I/O takes a
+        # bare pid (no handle / task port pins the target as on Windows and
+        # macOS), so once the target exits and is reaped the pid can be
+        # recycled and every later call would silently hit an unrelated
+        # process. A pidfd refers to the original process for its whole
+        # lifetime; where pidfds are unavailable, the /proc start time —
+        # unique per (pid, boot) — stands in. Both are verified before each
+        # operation (see `__require_target`).
+        self.__pidfd: Optional[int] = open_pidfd(self.pid)
+        self.__start_time: Optional[int] = read_start_time(self.pid)
         self.__closed = False
 
         # `permission` is accepted for cross-platform parity but has no effect
@@ -87,24 +107,88 @@ class LinuxProcess(AbstractProcess):
         if self.__closed:
             raise ClosedProcess()
 
+    def __require_target(self, *, hot_path: bool = False) -> None:
+        """
+        Raise ``ClosedProcess`` after ``close()``, and
+        :class:`~PyMemoryEditor.ProcessIDNotExistsError` once the process this
+        object was opened on has exited — even if its pid now belongs to
+        another process. One ``pidfd_send_signal`` per call on kernels with
+        pidfds (5.3+, ~0.3 us); a ``/proc/<pid>/stat`` read otherwise.
+
+        ``hot_path`` marks single-value reads, which callers issue in tight
+        loops: they are verified only when the cheap pidfd probe is
+        available. Without a pidfd the start-time read would roughly
+        quadruple the cost of every read, so there they keep the pre-pidfd
+        behaviour. Writes, scans and listings are always verified.
+        """
+        self.__require_open()
+        if hot_path and self.__pidfd is None:
+            return
+        if not self._target_alive():
+            raise ProcessIDNotExistsError(self.pid)
+
+    def _target_alive(self) -> bool:
+        pidfd = self.__pidfd
+        if pidfd is not None:
+            alive = pidfd_alive(pidfd)
+            if alive is not None:
+                return alive
+        if self.__start_time is not None:
+            current = read_start_time(self.pid)
+            if current is not None:
+                return current == self.__start_time
+            # Unreadable now: gone (no /proc entry) or hidden — ask by pid.
+            return process_exists(self.pid)
+        return super()._target_alive()
+
     def close(self) -> bool:
+        if self.__closed:
+            return True
+
         self.__closed = True
+        pidfd, self.__pidfd = self.__pidfd, None
+        if pidfd is not None:
+            try:
+                os.close(pidfd)
+            except OSError as exc:
+                # Never raise from close() (`__exit__` / `__del__` call it);
+                # report through the return value like the Windows backend.
+                _logger.warning(
+                    "Closing the pidfd of process %d failed: %s", self.pid, exc
+                )
+                return False
         return True
 
+    def __del__(self) -> None:
+        """
+        Best-effort safety net for callers who forget to ``close()`` / use
+        the context manager: releases the pidfd, mirroring how the Windows and
+        macOS backends release their handle / task port. ``__del__`` is not
+        guaranteed to run, so this is only a fallback.
+        """
+        # Construction failed before the pidfd was set: nothing to release.
+        if getattr(self, "_LinuxProcess__closed", True):
+            return
+        try:
+            self.close()
+        except Exception:
+            # __del__ must not raise; the interpreter may be shutting down.
+            pass
+
     def _detect_is_64bit(self) -> Optional[bool]:
-        self.__require_open()
+        self.__require_target()
         return _detect_process_64bit(self.pid)
 
     def get_memory_regions(self) -> Generator[MemoryRegion, None, None]:
-        self.__require_open()
+        self.__require_target()
         return get_memory_regions(self.pid)
 
     def get_threads(self) -> Generator[ThreadInfo, None, None]:
-        self.__require_open()
+        self.__require_target()
         return get_threads(self.pid)
 
     def get_modules(self) -> Generator[ModuleInfo, None, None]:
-        self.__require_open()
+        self.__require_target()
         return get_modules(self.pid)
 
     def read_process_memory(
@@ -113,13 +197,13 @@ class LinuxProcess(AbstractProcess):
         pytype: Type[T],
         bufflength: Optional[int] = None,
     ) -> T:
-        self.__require_open()
+        self.__require_target(hot_path=True)
         return read_process_memory(
             self.pid, address, pytype, resolve_bufflength(pytype, bufflength)
         )
 
     def read_process_memory_into(self, address: int, buffer: object) -> int:
-        self.__require_open()
+        self.__require_target(hot_path=True)
         return read_process_memory_into(self.pid, address, buffer)
 
     def search_by_addresses(
@@ -131,7 +215,7 @@ class LinuxProcess(AbstractProcess):
         raise_error: bool = False,
         memory_regions: Optional[Sequence[MemoryRegion]] = None,
     ) -> Generator[Tuple[int, Optional[T]], None, None]:
-        self.__require_open()
+        self.__require_target()
         if addresses is UNSET:
             raise TypeError("addresses is required.")
         return search_values_by_addresses(
@@ -155,7 +239,7 @@ class LinuxProcess(AbstractProcess):
         memory_regions: Optional[Sequence[MemoryRegion]] = None,
         aligned: bool = True,
     ) -> Generator[Union[int, Tuple[int, dict]], None, None]:
-        self.__require_open()
+        self.__require_target()
 
         if scan_type in [ScanTypesEnum.VALUE_BETWEEN, ScanTypesEnum.NOT_VALUE_BETWEEN]:
             raise ValueError(
@@ -182,7 +266,7 @@ class LinuxProcess(AbstractProcess):
         progress_information: bool = False,
         memory_regions: Optional[Sequence[MemoryRegion]] = None,
     ) -> Generator[Union[int, Tuple[int, dict]], None, None]:
-        self.__require_open()
+        self.__require_target()
         return search_addresses_by_pattern(
             self.pid,
             pattern,
@@ -204,7 +288,7 @@ class LinuxProcess(AbstractProcess):
         memory_regions: Optional[Sequence[MemoryRegion]] = None,
         aligned: bool = True,
     ) -> Generator[Union[int, Tuple[int, dict]], None, None]:
-        self.__require_open()
+        self.__require_target()
 
         scan_type = (
             ScanTypesEnum.NOT_VALUE_BETWEEN
@@ -230,7 +314,7 @@ class LinuxProcess(AbstractProcess):
         bufflength: Optional[int] = None,
         value: Union[bool, int, float, str, bytes] = UNSET,
     ) -> Union[bool, int, float, str, bytes]:
-        self.__require_open()
+        self.__require_target()
         w_pytype, w_length, w_value = prepare_write(pytype, bufflength, value)
         write_process_memory(self.pid, address, w_pytype, w_length, w_value)
         return value