injectlib 0.0.2__tar.gz → 0.0.3__tar.gz

{injectlib-0.0.2 → injectlib-0.0.3}/MANIFEST.in

@@ -13,4 +13,8 @@ include src/injectlib/libs/hook/x86/pywinmsg32u.dll
 include src/injectlib/libs/hook/x64/pywinmsg64.dll
 include src/injectlib/libs/hook/x64/pywinmsg64u.dll
 
-include src/injectlib/libs/qt/x64/qt_srv.dll
+include src/injectlib/libs/qt5/x86/qt5_srv.dll
+include src/injectlib/libs/qt5/x64/qt5_srv.dll
+include src/injectlib/libs/qt5/x64/qt5_srv.so
+include src/injectlib/libs/qt6/x64/qt6_srv.dll
+include src/injectlib/libs/qt6/x64/qt6_srv.so

{injectlib-0.0.2/src/injectlib.egg-info → injectlib-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: injectlib
-Version: 0.0.2
+Version: 0.0.3
 Summary: A set of Python modules to inject DLLs into applications for the Microsoft Windows
 Home-page: https://github.com/pywinauto/injectlib
 Author: Vasily Ryabov, Ilya Naumov, Boris Galochkin, Alexander Makarov and contributors
@@ -9,6 +9,7 @@ License: BSD-3-Clause
 Project-URL: GitHub, https://github.com/pywinauto/injectlib
 Keywords: windows gui .net inject testing test desktop dll wpf qt
 Platform: win32
+Platform: linux
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -28,7 +29,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.7
 License-File: LICENSE
-Requires-Dist: pywin32
+Requires-Dist: pywin32; platform_system == "Windows"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{injectlib-0.0.2 → injectlib-0.0.3}/README.md

@@ -52,28 +52,34 @@ Link to PyPi: <https://pypi.org/project/injectlib/>
 * MSBuild
 * MSVC >= 143
 * cmake >= 3.26.3
-* Qt >= 5.15.2, < 6
+* Qt 5 >= 5.15.2, < 6
+* Qt 6
 
   **NOTE**: You may use PyCharm + Visual Studio with C++/C# components for
   development
 
 ### Building Qt DLL
 
-This package compiles C++ binaries that link against **Qt 5** (>=5.15.2, <6).
-Qt is not bundled and must be installed separately before building.
+This package compiles C++ binaries that link against **Qt 5** (>=5.15.2, <6) and **Qt 6**. Qt is not bundled and must be installed separately before building
 
 - **Windows** download options:
-  - download via [Qt Online Installer](https://www.qt.io/download) and select the MSVC 2019 64-bit component. Registration required. Installation might be banned for some countries
-  - via mirrors, for example, https://mirror.yandex.ru/mirrors/qt.io. Base package for Qt 5.15.2 can be found [here](https://mirror.yandex.ru/mirrors/qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5152/qt.qt5.5152.win64_msvc2019_64/5.15.2-0-202011130602qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z). No registration required.
+  - download via [Qt Online Installer](https://www.qt.io/download) and select the MSVC components. Registration required. Only 64-bit supported. Installation might be banned for some countries.
+  - via mirrors, for example, https://mirror.yandex.ru/mirrors/qt.io.
+    - Base package for Qt 5.15.2 x64 can be found [here](https://mirror.yandex.ru/mirrors/qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5152/qt.qt5.5152.win64_msvc2019_64/5.15.2-0-202011130602qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z). No registration required.
+    - Base package for Qt 5.15.2 x86 can be found [here](https://mirror.yandex.ru/mirrors/qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5152/qt.qt5.5152.win32_msvc2019/5.15.2-0-202011130602qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z). No registration required.
+    - Base package for Qt 6.9.3 can be found [here](https://mirror.yandex.ru/mirrors/qt.io/online/qtsdkrepository/windows_x86/desktop/qt6_693/qt6_693/qt.qt6.693.win64_msvc2022_64/6.9.3-0-202509261208qtbase-Windows-Windows_11_23H2-MSVC2022-Windows-Windows_11_23H2-X86_64.7z)
 
-Once installed, point CMake to your Qt installation by setting `CMAKE_PREFIX_PATH`:
+Once installed, point CMake to your Qt installations by setting `CMAKE_PREFIX_PATH` and add the Qt runtime directories to `PATH`.
+
+For example:
 
 ```bash
 # Windows (adjust version/compiler as needed)
-set CMAKE_PREFIX_PATH=C:/Qt/5.15.2/msvc2019_64
+set CMAKE_PREFIX_PATH=C:\Qt\5.15.2\msvc2019;C:\Qt\5.15.2\msvc2019_64;C:\Qt\6.9.1\msvc2022_64
+set PATH=C:\Qt\5.15.2\msvc2019\bin;C:\Qt\5.15.2\msvc2019_64\bin;C:\Qt\6.9.1\msvc2022_64\bin;%PATH%
 ```
 
-If CMake still cannot find Qt, verify the path contains a `lib/cmake/Qt5` subdirectory.
+If CMake still cannot find Qt, verify the paths contain `lib/cmake/Qt5` and `lib/cmake/Qt6` subdirectories.
 
 ## License
 

{injectlib-0.0.2 → injectlib-0.0.3}/setup.py

@@ -12,6 +12,7 @@ from setuptools.dist import Distribution
 x86_cmake_arch_name, x64_cmake_arch_name = 'Win32', 'x64'
 x86_package_arch_name, x64_package_arch_name = 'x86', 'x64'
 
+is_windows = sys.platform == 'win32'
 is_64bit = sys.maxsize > 2**32
 if is_64bit:
     arch_names_map = { x64_cmake_arch_name: x64_package_arch_name }
@@ -19,8 +20,19 @@ else:
     arch_names_map = { x86_cmake_arch_name: x86_package_arch_name }
 
 build_dirname = 'build_'
-build_dll_dirs = ['./backends/dotnet/', './backends/hook/', './backends/qt/']
-package_dll_dirs = ['./src/injectlib/libs/dotnet/', './src/injectlib/libs/hook/', './src/injectlib/libs/qt/']
+if is_windows:
+    build_dll_dirs = ['./backends/dotnet/',
+                      './backends/hook/',
+                      './backends/qt5/']
+    package_dll_dirs = ['./src/injectlib/libs/dotnet/',
+                        './src/injectlib/libs/hook/',
+                        './src/injectlib/libs/qt5/']
+else:
+    build_dll_dirs = ['./backends/qt5/']
+    package_dll_dirs = ['./src/injectlib/libs/qt5/']
+if is_64bit:
+    build_dll_dirs.append('./backends/qt6/')
+    package_dll_dirs.append('./src/injectlib/libs/qt6/')
 cmake_dirs = build_dll_dirs
 
 
@@ -35,7 +47,10 @@ class SdistWithDlls(sdist):
 
                 os.makedirs(build_dir, exist_ok=True)
 
-                subprocess.check_call(['cmake', '-B ' + build_dir, '-S ' + cmake_dir, '-A ' + arch])
+                cmake_command = ['cmake', '-B ' + build_dir, '-S ' + cmake_dir]
+                if is_windows:
+                    cmake_command.extend(['-A', arch])
+                subprocess.check_call(cmake_command)
                 subprocess.check_call(['cmake', '--build', build_dir, '--config', 'Release'])
 
         # copy DLLs to the package
@@ -43,7 +58,7 @@ class SdistWithDlls(sdist):
             for build_dll_dir, package_dll_dir in zip(build_dll_dirs, package_dll_dirs):
                 for root, _, files in os.walk(build_dll_dir + build_dirname + arch):
                     for file in files:
-                        if file.endswith('.dll'):
+                        if file.endswith(('.dll', '.so')):
                             src_file_path = os.path.join(root, file)
                             dest_file_path = os.path.join(package_dll_dir + arch_names_map.get(arch), file)
                             os.makedirs(os.path.dirname(dest_file_path), exist_ok=True)
@@ -57,7 +72,7 @@ class BinaryDistribution(Distribution):
 
 
 setup(name='injectlib',
-      version='0.0.2',
+      version='0.0.3',
       description='A set of Python modules to inject DLLs into applications for the Microsoft Windows',
       keywords="windows gui .net inject testing test desktop dll wpf qt",
       url="https://github.com/pywinauto/injectlib",
@@ -80,7 +95,7 @@ precision and coverage than standard OS APIs like MS UI Automation API or
 Win32 API. Other use cases are potentially possible at
 your own risk according to the law and the project license.
 """,
-      platforms=['win32'],
+      platforms=['win32', 'linux'],
 
       packages=["injectlib"],
       package_dir={"": "src"},
@@ -106,7 +121,7 @@ your own risk according to the law and the project license.
           'Topic :: Software Development :: Libraries :: Python Modules',
           'Topic :: Software Development :: Testing',
       ],
-      install_requires=['pywin32'],
+      install_requires=['pywin32; platform_system=="Windows"'],
       python_requires='>=3.7',
       cmdclass={'sdist': SdistWithDlls},
       )

{injectlib-0.0.2 → injectlib-0.0.3}/src/injectlib/api.py

@@ -1,8 +1,12 @@
 import json
 import logging
+import sys
 
-from .injector import Injector
 from .channel import Pipe
+if sys.platform == "win32":
+    from .injector import Injector
+else:
+    from .linux_injector import LinuxInjector as Injector
 
 logger = logging.getLogger(__package__)
 
@@ -51,6 +55,11 @@ class Singleton(type):
 class ConnectionManager(object, metaclass=Singleton):
     def __init__(self):
         self._pipes = {}
+        self._backend_config = {}
+
+    def register_backend(self, pid, backend_name, dll_name):
+        """Register backend to use when injecting into pid. Must be called before the first call_action for that pid."""
+        self._backend_config[pid] = (backend_name, dll_name)
 
     def _get_pipe(self, pid):
         if pid not in self._pipes:
@@ -65,8 +74,12 @@ class ConnectionManager(object, metaclass=Singleton):
             return pipe
         else:
             logger.info('Pipe {} not found, injecting dll to the process'.format(pipe_name))
-            Injector(pid, 'dotnet', 'bootstrap')
-            pipe.connect()
+            # Fallback to dotnet to keep compatibility
+            backend_name, dll_name = self._backend_config.get(pid, ('dotnet', 'bootstrap'))
+            Injector(pid, backend_name, dll_name)
+            if not pipe.connect():
+                raise InjectedRuntimeError(
+                    "Injected server channel did not appear for pid {}".format(pid))
             return pipe
 
     def call_action(self, action_name, pid, **params):

injectlib-0.0.3/src/injectlib/cfuncs.py

@@ -0,0 +1,245 @@
+"""Some functions already exists in pywinauto, but for correctly
+injector work needs full redefinition with ctypes compatible
+"""
+
+import os
+import sys
+from ctypes import Structure, sizeof, alignment
+from ctypes import c_char_p, c_wchar_p
+from ctypes import POINTER
+
+if sys.platform == "win32":
+    import win32con
+    from ctypes import windll
+    from ctypes.wintypes import BOOL, DWORD, HANDLE, LPVOID, LPCVOID
+else:
+    import ctypes
+    from ctypes import c_int, c_long, c_ulonglong, c_void_p, byref
+
+
+if sys.platform == "win32":
+    class SECURITY_ATTRIBUTES(Structure):
+        _fields_ = [
+            ('nLength', DWORD),
+            ('lpSecurityDescriptor', LPVOID),
+            ('bInheritHandle', BOOL),
+        ]
+
+    assert sizeof(SECURITY_ATTRIBUTES) == 12 or sizeof(SECURITY_ATTRIBUTES) == 24, sizeof(SECURITY_ATTRIBUTES)
+    assert alignment(SECURITY_ATTRIBUTES) == 4 or alignment(SECURITY_ATTRIBUTES) == 8, alignment(SECURITY_ATTRIBUTES)
+
+    PAGE_READWRITE = win32con.PAGE_READWRITE
+    WAIT_TIMEOUT = win32con.WAIT_TIMEOUT
+    PROCESS_ALL_ACCESS = win32con.PROCESS_ALL_ACCESS
+    VIRTUAL_MEM = (win32con.MEM_RESERVE | win32con.MEM_COMMIT)
+    LPCSTR = LPCTSTR = c_char_p
+    LPWTSTR = c_wchar_p
+    LPDWORD = PDWORD = POINTER(DWORD)
+    LPTHREAD_START_ROUTINE = LPVOID
+    LPSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES)
+
+    OpenProcess = windll.kernel32.OpenProcess
+    OpenProcess.restype = HANDLE
+    OpenProcess.argtypes = (DWORD, BOOL, DWORD)
+
+    VirtualAllocEx = windll.kernel32.VirtualAllocEx
+    VirtualAllocEx.restype = LPVOID
+    VirtualAllocEx.argtypes = (HANDLE, LPVOID, DWORD, DWORD, DWORD)
+
+    ReadProcessMemory = windll.kernel32.ReadProcessMemory
+    ReadProcessMemory.restype = BOOL
+    ReadProcessMemory.argtypes = (HANDLE, LPCVOID, LPVOID, DWORD, DWORD)
+
+    WriteProcessMemory = windll.kernel32.WriteProcessMemory
+    WriteProcessMemory.restype = BOOL
+    WriteProcessMemory.argtypes = (HANDLE, LPVOID, LPCVOID, DWORD, DWORD)
+
+    CreateRemoteThread = windll.kernel32.CreateRemoteThread
+    CreateRemoteThread.restype = HANDLE
+    CreateRemoteThread.argtypes = (HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD)
+
+    GetModuleHandleA = windll.kernel32.GetModuleHandleA
+    GetModuleHandleA.restype = HANDLE
+    GetModuleHandleA.argtypes = (LPCTSTR,)
+
+    LoadLibraryA = windll.kernel32.LoadLibraryA
+    LoadLibraryA.restype = HANDLE
+    LoadLibraryA.argtypes = (LPCTSTR,)
+
+    GetModuleHandleW = windll.kernel32.GetModuleHandleW
+    GetModuleHandleW.restype = HANDLE
+    GetModuleHandleW.argtypes = (LPWTSTR,)
+
+    LoadLibraryW = windll.kernel32.LoadLibraryW
+    LoadLibraryW.restype = HANDLE
+    LoadLibraryW.argtypes = (LPWTSTR,)
+
+    GetProcAddress = windll.kernel32.GetProcAddress
+    GetProcAddress.restype = LPVOID
+    GetProcAddress.argtypes = (HANDLE, LPCTSTR)
+
+    WaitForSingleObject = windll.kernel32.WaitForSingleObject
+    WaitForSingleObject.restype = DWORD
+    WaitForSingleObject.argtypes = (HANDLE, DWORD)
+else:
+    PTRACE_PEEKDATA = 2
+    PTRACE_POKEDATA = 5
+    PTRACE_CONT = 7
+    PTRACE_GETREGS = 12
+    PTRACE_SETREGS = 13
+    PTRACE_ATTACH = 16
+    PTRACE_DETACH = 17
+    RTLD_NOW = 2
+    RTLD_GLOBAL = 0x100
+    SIGTRAP = 5
+
+    libc = ctypes.CDLL(None, use_errno=True)
+    try:
+        libdl = ctypes.CDLL("libdl.so.2", use_errno=True)
+    except OSError:
+        libdl = libc
+
+    ptrace = libc.ptrace
+    ptrace.restype = c_long
+    ptrace.argtypes = (c_int, c_int, c_void_p, c_void_p)
+
+    waitpid = libc.waitpid
+    waitpid.restype = c_int
+    waitpid.argtypes = (c_int, POINTER(c_int), c_int)
+
+    dlopen = libdl.dlopen
+    dlopen.restype = c_void_p
+    dlopen.argtypes = (c_char_p, c_int)
+
+    class UserRegsStruct(Structure):
+        _fields_ = [
+            ("r15", c_ulonglong),
+            ("r14", c_ulonglong),
+            ("r13", c_ulonglong),
+            ("r12", c_ulonglong),
+            ("rbp", c_ulonglong),
+            ("rbx", c_ulonglong),
+            ("r11", c_ulonglong),
+            ("r10", c_ulonglong),
+            ("r9", c_ulonglong),
+            ("r8", c_ulonglong),
+            ("rax", c_ulonglong),
+            ("rcx", c_ulonglong),
+            ("rdx", c_ulonglong),
+            ("rsi", c_ulonglong),
+            ("rdi", c_ulonglong),
+            ("orig_rax", c_ulonglong),
+            ("rip", c_ulonglong),
+            ("cs", c_ulonglong),
+            ("eflags", c_ulonglong),
+            ("rsp", c_ulonglong),
+            ("ss", c_ulonglong),
+            ("fs_base", c_ulonglong),
+            ("gs_base", c_ulonglong),
+            ("ds", c_ulonglong),
+            ("es", c_ulonglong),
+            ("fs", c_ulonglong),
+            ("gs", c_ulonglong),
+        ]
+
+    def _wifstopped(status):
+        return (status & 0xff) == 0x7f
+
+    def _wstopsig(status):
+        return (status >> 8) & 0xff
+
+    def _ptrace(request, pid, address=0, data=0):
+        ctypes.set_errno(0)
+        result = ptrace(request, pid, c_void_p(address), c_void_p(data))
+        if result == -1 and ctypes.get_errno() != 0:
+            raise OSError(ctypes.get_errno(), os.strerror(ctypes.get_errno()))
+        return result
+
+    def ptrace_attach(pid):
+        _ptrace(PTRACE_ATTACH, pid)
+        status = c_int()
+        if waitpid(pid, byref(status), 0) < 0:
+            raise OSError(ctypes.get_errno(), os.strerror(ctypes.get_errno()))
+        if not _wifstopped(status.value):
+            raise RuntimeError("target did not stop after ptrace attach")
+
+    def ptrace_detach(pid):
+        _ptrace(PTRACE_DETACH, pid)
+
+    def ptrace_continue(pid):
+        _ptrace(PTRACE_CONT, pid)
+        status = c_int()
+        if waitpid(pid, byref(status), 0) < 0:
+            raise OSError(ctypes.get_errno(), os.strerror(ctypes.get_errno()))
+        if not _wifstopped(status.value):
+            raise RuntimeError("target did not stop after remote call")
+        return _wstopsig(status.value)
+
+    def ptrace_getregs(pid):
+        regs = UserRegsStruct()
+        _ptrace(PTRACE_GETREGS, pid, 0, ctypes.addressof(regs))
+        return regs
+
+    def ptrace_setregs(pid, regs):
+        _ptrace(PTRACE_SETREGS, pid, 0, ctypes.addressof(regs))
+
+    def read_target(pid, address, size):
+        data = bytearray()
+        word_size = sizeof(c_long)
+        offset = 0
+        while offset < size:
+            word = _ptrace(PTRACE_PEEKDATA, pid, address + offset, 0)
+            chunk = ctypes.string_at(byref(c_long(word)), word_size)
+            data.extend(chunk[:min(word_size, size - offset)])
+            offset += word_size
+        return bytes(data)
+
+    def write_target(pid, address, data):
+        word_size = sizeof(c_long)
+        offset = 0
+        while offset < len(data):
+            chunk = data[offset:offset + word_size]
+            if len(chunk) != word_size:
+                current = bytearray(read_target(pid, address + offset, word_size))
+                current[:len(chunk)] = chunk
+                chunk = bytes(current)
+            word = c_long.from_buffer_copy(chunk)
+            _ptrace(PTRACE_POKEDATA, pid, address + offset, word.value & ((1 << (word_size * 8)) - 1))
+            offset += word_size
+
+    def module_base_from_maps(pid, module_basename):
+        with open("/proc/{}/maps".format(pid), "r") as maps_file:
+            for line in maps_file:
+                parts = line.split()
+                if len(parts) < 6 or "x" not in parts[1]:
+                    continue
+                path = parts[-1]
+                if os.path.basename(path) != module_basename:
+                    continue
+                start = int(parts[0].split("-", 1)[0], 16)
+                offset = int(parts[2], 16)
+                return start - offset
+        return None
+
+    def local_module_for_address(address):
+        with open("/proc/{}/maps".format(os.getpid()), "r") as maps_file:
+            for line in maps_file:
+                parts = line.split()
+                if len(parts) < 6:
+                    continue
+                start_s, end_s = parts[0].split("-", 1)
+                start = int(start_s, 16)
+                end = int(end_s, 16)
+                if start <= address < end:
+                    return os.path.basename(parts[-1]), start - int(parts[2], 16)
+        return None, None
+
+    def remote_symbol_address(pid, local_symbol):
+        local_address = ctypes.cast(local_symbol, c_void_p).value
+        module_name, local_base = local_module_for_address(local_address)
+        if not module_name or not local_base:
+            return None
+        remote_base = module_base_from_maps(pid, module_name)
+        if not remote_base:
+            return None
+        return remote_base + (local_address - local_base)

injectlib-0.0.3/src/injectlib/channel.py

@@ -0,0 +1,130 @@
+import logging
+import os
+import socket
+import sys
+import time
+
+logger = logging.getLogger(__package__)
+
+if sys.platform == "win32":
+    import pywintypes
+    import win32file
+    import win32pipe
+    import winerror
+
+
+class InjectedBrokenPipeError(Exception):
+    pass
+
+
+if sys.platform == "win32":
+    class Pipe(object):
+        def __init__(self, name):
+            self.name = name
+            self.handle = None
+
+        def connect(self, n_attempts=30, delay=1):
+            for i in range(n_attempts):
+                try:
+                    self.handle = win32file.CreateFile(
+                        r'\\.\pipe\{}'.format(self.name),
+                        win32file.GENERIC_READ | win32file.GENERIC_WRITE,
+                        0,
+                        None,
+                        win32file.OPEN_EXISTING,
+                        0,
+                        None
+                    )
+                    win32pipe.SetNamedPipeHandleState(
+                        self.handle,
+                        win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT,
+                        None,
+                        None,
+                    )
+                    logger.info('Connected to the pipe {}'.format(self.name))
+                    break
+                except pywintypes.error as e:
+                    if e.args[0] == winerror.ERROR_FILE_NOT_FOUND:
+                        logger.warning('Attempt {}/{}: failed to connect to the pipe {}'.format(
+                            i + 1, n_attempts, self.name))
+                        time.sleep(delay)
+                    else:
+                        raise InjectedBrokenPipeError('Unexpected pipe error: {}'.format(e))
+            if self.handle is not None:
+                return True
+            return False
+
+        def transact(self, string):
+            try:
+                # TODO get preferred encoding from application
+                self.write(string, 'utf-8')
+                resp = win32file.ReadFile(self.handle, 64 * 1024)
+                return resp[1].decode('utf-8')
+            except pywintypes.error as e:
+                if e.args[0] == winerror.ERROR_BROKEN_PIPE:
+                    raise InjectedBrokenPipeError("Broken pipe")
+                else:
+                    raise InjectedBrokenPipeError('Unexpected pipe error: {}'.format(e))
+
+        def close(self):
+            win32file.CloseHandle(self.handle)
+
+        def write(self, string, encoding='utf-8'):
+            """Write string with the specified encoding to the named pipe."""
+            win32file.WriteFile(self.handle, string.encode(encoding))
+            win32file.FlushFileBuffers(self.handle)
+
+else:
+    class Pipe(object):
+        def __init__(self, name):
+            self.name = name
+            self.path = "/tmp/injectlib_qt_{0}_{1}.sock".format(
+                os.getuid(), name.rsplit("_", 1)[-1])
+
+        def connect(self, n_attempts=30, delay=1):
+            for i in range(n_attempts):
+                client = None
+                try:
+                    client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+                    client.connect(self.path)
+                    return True
+                except OSError:
+                    pass
+                finally:
+                    if client is not None:
+                        try:
+                            client.close()
+                        except Exception:
+                            pass
+
+                if i < n_attempts - 1:
+                    logger.warning('Attempt {}/{}: failed to connect to the socket {}'.format(
+                        i + 1, n_attempts, self.path))
+                    time.sleep(delay)
+            return False
+
+        def transact(self, string):
+            client = None
+            try:
+                client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+                client.connect(self.path)
+                client.sendall(string.encode("utf-8"))
+                client.shutdown(socket.SHUT_WR)
+                chunks = []
+                while True:
+                    chunk = client.recv(64 * 1024)
+                    if not chunk:
+                        break
+                    chunks.append(chunk)
+                return b"".join(chunks).decode("utf-8")
+            except OSError as exc:
+                raise InjectedBrokenPipeError('Unexpected socket error: {}'.format(exc))
+            finally:
+                if client is not None:
+                    try:
+                        client.close()
+                    except Exception:
+                        pass
+
+        def close(self):
+            pass

injectlib-0.0.3/src/injectlib/linux_injector.py

@@ -0,0 +1,112 @@
+import os
+import platform
+import struct
+
+from . import cfuncs
+
+
+class LinuxInjector(object):
+    """Load an injectlib shared object into a same-user Linux process."""
+
+    def __init__(self, pid, backend_name, dll_name):
+        self.pid = int(pid)
+        self.backend_name = backend_name
+        self.dll_name = dll_name
+        self._validate_process()
+        self.library_path = self._library_path()
+        self._inject_shared_object()
+
+    def _validate_process(self):
+        proc_dir = "/proc/{}".format(self.pid)
+        if not os.path.isdir(proc_dir):
+            raise RuntimeError("Target process does not exist: pid={}".format(self.pid))
+        if platform.machine().lower() not in ("x86_64", "amd64"):
+            raise RuntimeError("Linux Qt attach currently supports x86_64 only")
+
+    def _library_path(self):
+        arch = "x64"
+        path = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "libs",
+            self.backend_name,
+            arch,
+            "{}.so".format(self.dll_name),
+        )
+        if not os.path.isfile(path):
+            raise RuntimeError("Linux Qt server library is missing: {}".format(path))
+        return path
+
+    def _inject_shared_object(self):
+        remote_dlopen = cfuncs.remote_symbol_address(self.pid, cfuncs.dlopen)
+        if not remote_dlopen:
+            raise RuntimeError("Cannot resolve remote dlopen address for pid {}".format(self.pid))
+
+        cfuncs.ptrace_attach(self.pid)
+        saved_payload = None
+        saved_code = None
+        saved_regs = None
+        stack_addr = None
+        code_len = None
+        try:
+            regs = cfuncs.ptrace_getregs(self.pid)
+            saved_regs = cfuncs.UserRegsStruct()
+            for field, _ in cfuncs.UserRegsStruct._fields_:
+                setattr(saved_regs, field, getattr(regs, field))
+
+            code, path_addr = self._remote_dlopen_stub(remote_dlopen, regs.rsp)
+            code_len = len(code)
+            payload = self.library_path.encode("utf-8") + b"\0"
+            payload_len = ((128 + len(payload) + 7) // 8) * 8
+            stack_addr = (regs.rsp - payload_len - 128) & ~0xF
+            path_addr = stack_addr + 128
+            code, _ = self._remote_dlopen_stub(remote_dlopen, regs.rsp, path_addr)
+
+            saved_payload = cfuncs.read_target(self.pid, stack_addr, payload_len)
+            saved_code = cfuncs.read_target(self.pid, regs.rip, code_len)
+
+            stack_payload = bytearray(payload_len)
+            stack_payload[128:128 + len(payload)] = payload
+            cfuncs.write_target(self.pid, stack_addr, bytes(stack_payload))
+            cfuncs.write_target(self.pid, regs.rip, code)
+
+            regs.rip = saved_regs.rip
+            regs.rsp = stack_addr
+            cfuncs.ptrace_setregs(self.pid, regs)
+            stop_signal = cfuncs.ptrace_continue(self.pid)
+            if stop_signal != cfuncs.SIGTRAP:
+                raise RuntimeError("Remote dlopen stopped with unexpected signal {}".format(stop_signal))
+
+            after = cfuncs.ptrace_getregs(self.pid)
+            if after.rax == 0:
+                raise RuntimeError("Remote dlopen returned NULL for {}".format(self.library_path))
+        finally:
+            if saved_payload is not None and stack_addr is not None:
+                cfuncs.write_target(self.pid, stack_addr, saved_payload)
+            if saved_code is not None and saved_regs is not None and code_len is not None:
+                cfuncs.write_target(self.pid, saved_regs.rip, saved_code[:code_len])
+            if saved_regs is not None:
+                cfuncs.ptrace_setregs(self.pid, saved_regs)
+            cfuncs.ptrace_detach(self.pid)
+
+        if not self._target_has_library():
+            raise RuntimeError("Remote dlopen did not map {} in pid {}".format(
+                self.library_path, self.pid))
+
+    def _remote_dlopen_stub(self, remote_dlopen, stack_pointer, path_addr=None):
+        if path_addr is None:
+            path_addr = stack_pointer
+        code = bytearray()
+        code.extend(b"\x48\xb8")
+        code.extend(struct.pack("<Q", remote_dlopen))
+        code.extend(b"\x48\xbf")
+        code.extend(struct.pack("<Q", path_addr))
+        code.extend(b"\xbe")
+        code.extend(struct.pack("<I", cfuncs.RTLD_NOW | cfuncs.RTLD_GLOBAL))
+        code.extend(b"\xff\xd0")
+        code.extend(b"\xcc")
+        return bytes(code), path_addr
+
+    def _target_has_library(self):
+        real_library = os.path.realpath(self.library_path)
+        with open("/proc/{}/maps".format(self.pid), "r") as maps_file:
+            return any(real_library in line for line in maps_file)

{injectlib-0.0.2 → injectlib-0.0.3/src/injectlib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: injectlib
-Version: 0.0.2
+Version: 0.0.3
 Summary: A set of Python modules to inject DLLs into applications for the Microsoft Windows
 Home-page: https://github.com/pywinauto/injectlib
 Author: Vasily Ryabov, Ilya Naumov, Boris Galochkin, Alexander Makarov and contributors
@@ -9,6 +9,7 @@ License: BSD-3-Clause
 Project-URL: GitHub, https://github.com/pywinauto/injectlib
 Keywords: windows gui .net inject testing test desktop dll wpf qt
 Platform: win32
+Platform: linux
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -28,7 +29,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.7
 License-File: LICENSE
-Requires-Dist: pywin32
+Requires-Dist: pywin32; platform_system == "Windows"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{injectlib-0.0.2 → injectlib-0.0.3}/src/injectlib.egg-info/SOURCES.txt

@@ -1,12 +1,14 @@
 LICENSE
 MANIFEST.in
 README.md
+pyproject.toml
 setup.py
 src/injectlib/__init__.py
 src/injectlib/api.py
 src/injectlib/cfuncs.py
 src/injectlib/channel.py
 src/injectlib/injector.py
+src/injectlib/linux_injector.py
 src/injectlib/sysinfo.py
 src/injectlib.egg-info/PKG-INFO
 src/injectlib.egg-info/SOURCES.txt
@@ -23,4 +25,8 @@ src/injectlib/libs/hook/x64/pywinmsg64.dll
 src/injectlib/libs/hook/x64/pywinmsg64u.dll
 src/injectlib/libs/hook/x86/pywinmsg32.dll
 src/injectlib/libs/hook/x86/pywinmsg32u.dll
-src/injectlib/libs/qt/x64/qt_srv.dll
+src/injectlib/libs/qt5/x64/qt5_srv.dll
+src/injectlib/libs/qt5/x64/qt5_srv.so
+src/injectlib/libs/qt5/x86/qt5_srv.dll
+src/injectlib/libs/qt6/x64/qt6_srv.dll
+src/injectlib/libs/qt6/x64/qt6_srv.so

injectlib-0.0.3/src/injectlib.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[:platform_system == "Windows"]
+pywin32

injectlib-0.0.2/src/injectlib/cfuncs.py

@@ -1,76 +0,0 @@
-"""Some functions already exists in pywinauto, but for correctly
-injector work needs full redefinition with ctypes compatible
-"""
-
-import win32con
-from ctypes import Structure, sizeof, alignment
-from ctypes import c_char_p, c_wchar_p
-from ctypes import POINTER
-from ctypes import windll
-from ctypes.wintypes import BOOL, DWORD, HANDLE, LPVOID, LPCVOID
-
-
-class SECURITY_ATTRIBUTES(Structure):
-    _fields_ = [
-        ('nLength', DWORD),
-        ('lpSecurityDescriptor', LPVOID),
-        ('bInheritHandle', BOOL),
-    ]
-
-
-assert sizeof(SECURITY_ATTRIBUTES) == 12 or sizeof(SECURITY_ATTRIBUTES) == 24, sizeof(SECURITY_ATTRIBUTES)
-assert alignment(SECURITY_ATTRIBUTES) == 4 or alignment(SECURITY_ATTRIBUTES) == 8, alignment(SECURITY_ATTRIBUTES)
-
-PAGE_READWRITE = win32con.PAGE_READWRITE
-WAIT_TIMEOUT = win32con.WAIT_TIMEOUT
-PROCESS_ALL_ACCESS = win32con.PROCESS_ALL_ACCESS
-VIRTUAL_MEM = (win32con.MEM_RESERVE | win32con.MEM_COMMIT)
-LPCSTR = LPCTSTR = c_char_p
-LPWTSTR = c_wchar_p
-LPDWORD = PDWORD = POINTER(DWORD)
-LPTHREAD_START_ROUTINE = LPVOID
-LPSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES)
-
-OpenProcess = windll.kernel32.OpenProcess
-OpenProcess.restype = HANDLE
-OpenProcess.argtypes = (DWORD, BOOL, DWORD)
-
-VirtualAllocEx = windll.kernel32.VirtualAllocEx
-VirtualAllocEx.restype = LPVOID
-VirtualAllocEx.argtypes = (HANDLE, LPVOID, DWORD, DWORD, DWORD)
-
-ReadProcessMemory = windll.kernel32.ReadProcessMemory
-ReadProcessMemory.restype = BOOL
-ReadProcessMemory.argtypes = (HANDLE, LPCVOID, LPVOID, DWORD, DWORD)
-
-WriteProcessMemory = windll.kernel32.WriteProcessMemory
-WriteProcessMemory.restype = BOOL
-WriteProcessMemory.argtypes = (HANDLE, LPVOID, LPCVOID, DWORD, DWORD)
-
-CreateRemoteThread = windll.kernel32.CreateRemoteThread
-CreateRemoteThread.restype = HANDLE
-CreateRemoteThread.argtypes = (HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD)
-
-GetModuleHandleA = windll.kernel32.GetModuleHandleA
-GetModuleHandleA.restype = HANDLE
-GetModuleHandleA.argtypes = (LPCTSTR,)
-
-LoadLibraryA = windll.kernel32.LoadLibraryA
-LoadLibraryA.restype = HANDLE
-LoadLibraryA.argtypes = (LPCTSTR,)
-
-GetModuleHandleW = windll.kernel32.GetModuleHandleW
-GetModuleHandleW.restype = HANDLE
-GetModuleHandleW.argtypes = (LPWTSTR,)
-
-LoadLibraryW = windll.kernel32.LoadLibraryW
-LoadLibraryW.restype = HANDLE
-LoadLibraryW.argtypes = (LPWTSTR,)
-
-GetProcAddress = windll.kernel32.GetProcAddress
-GetProcAddress.restype = LPVOID
-GetProcAddress.argtypes = (HANDLE, LPCTSTR)
-
-WaitForSingleObject = windll.kernel32.WaitForSingleObject
-WaitForSingleObject.restype = DWORD
-WaitForSingleObject.argtypes = (HANDLE, DWORD)

injectlib-0.0.2/src/injectlib/channel.py

@@ -1,69 +0,0 @@
-import pywintypes
-import time
-import win32file
-import win32pipe
-import winerror
-import logging
-
-logger = logging.getLogger(__package__)
-
-
-class InjectedBrokenPipeError(Exception):
-    pass
-
-
-class Pipe(object):
-    def __init__(self, name):
-        self.name = name
-        self.handle = None
-
-    def connect(self, n_attempts=30, delay=1):
-        for i in range(n_attempts):
-            try:
-                self.handle = win32file.CreateFile(
-                    r'\\.\pipe\{}'.format(self.name),
-                    win32file.GENERIC_READ | win32file.GENERIC_WRITE,
-                    0,
-                    None,
-                    win32file.OPEN_EXISTING,
-                    0,
-                    None
-                )
-                win32pipe.SetNamedPipeHandleState(
-                    self.handle,
-                    win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT,
-                    None,
-                    None,
-                )
-                logger.info('Connected to the pipe {}'.format(self.name))
-                break
-            except pywintypes.error as e:
-                if e.args[0] == winerror.ERROR_FILE_NOT_FOUND:
-                    logger.warning('Attempt {}/{}: failed to connect to the pipe {}'.format(i + 1, n_attempts,
-                                                                                                self.name))
-                    time.sleep(delay)
-                else:
-                    raise InjectedBrokenPipeError('Unexpected pipe error: {}'.format(e))
-        if self.handle is not None:
-            return True
-        return False
-
-    def transact(self, string):
-        try:
-            # TODO get preferred encoding from application
-            self.write(string, 'utf-8')
-            resp = win32file.ReadFile(self.handle, 64 * 1024)
-            return resp[1].decode('utf-8')
-        except pywintypes.error as e:
-            if e.args[0] == winerror.ERROR_BROKEN_PIPE:
-                raise InjectedBrokenPipeError("Broken pipe")
-            else:
-                raise InjectedBrokenPipeError('Unexpected pipe error: {}'.format(e))
-
-    def close(self):
-        win32file.CloseHandle(self.handle)
-
-    def write(self, string, encoding='utf-8'):
-        """Write string with the specified encoding to the named pipe."""
-        win32file.WriteFile(self.handle, string.encode(encoding))
-        win32file.FlushFileBuffers(self.handle)

injectlib-0.0.2/src/injectlib.egg-info/requires.txt

@@ -1 +0,0 @@
-pywin32