injectlib 0.0.1__py2.py3-none-any.whl

injectlib/api.py

@@ -0,0 +1,90 @@
+import json
+import logging
+
+from .injector import Injector
+from .channel import Pipe
+
+logger = logging.getLogger(__package__)
+
+# backend exit codes enum
+OK = 0
+PARSE_ERROR = 1
+UNSUPPORTED_ACTION = 2
+MISSING_PARAM = 3
+RUNTIME_ERROR = 4
+NOT_FOUND = 5
+UNSUPPORTED_TYPE = 6
+INVALID_VALUE = 7
+
+
+class InjectedBaseError(Exception):
+    """Base class for exceptions based on errors returned from injected DLL side"""
+
+
+class InjectedUnsupportedActionError(InjectedBaseError):
+    """The specified action is not supported"""
+
+
+class InjectedRuntimeError(InjectedBaseError):
+    """Runtime exception during code execution inside injected target"""
+
+
+class InjectedNotFoundError(InjectedBaseError):
+    """Requested item not found: control element, property, ..."""
+
+
+class Singleton(type):
+    """
+    Singleton metaclass implementation from StackOverflow
+
+    http://stackoverflow.com/q/6760685/3648361
+    """
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class ConnectionManager(object, metaclass=Singleton):
+    def __init__(self):
+        self._pipes = {}
+
+    def _get_pipe(self, pid):
+        if pid not in self._pipes:
+            self._pipes[pid] = self._create_pipe(pid)
+        return self._pipes[pid]
+
+    def _create_pipe(self, pid):
+        pipe_name = 'process_{}'.format(pid)
+        pipe = Pipe(pipe_name)
+        if pipe.connect(n_attempts=1):
+            logger.info('Pipe {} found, looks like dll has been injected already'.format(pipe_name))
+            return pipe
+        else:
+            logger.info('Pipe {} not found, injecting dll to the process'.format(pipe_name))
+            Injector(pid, 'dotnet', 'bootstrap')
+            pipe.connect()
+            return pipe
+
+    def call_action(self, action_name, pid, **params):
+        command = {'action': action_name}
+        command.update(params)
+
+        reply = self._get_pipe(pid).transact(json.dumps(command))
+        reply = json.loads(reply)
+
+        reply_code = reply['status_code']
+
+        if reply_code == UNSUPPORTED_ACTION:
+            raise InjectedUnsupportedActionError(reply['message'])
+        elif reply_code == RUNTIME_ERROR:
+            raise InjectedRuntimeError(reply['message'])
+        elif reply_code == NOT_FOUND:
+            raise InjectedNotFoundError(reply['message'])
+        elif reply_code != OK:
+            raise InjectedBaseError()
+
+        return reply

injectlib/cfuncs.py

@@ -0,0 +1,76 @@
+"""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/channel.py

@@ -0,0 +1,69 @@
+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/injector.py

@@ -0,0 +1,89 @@
+import ctypes
+import locale
+import os
+
+from . import sysinfo
+from . import cfuncs
+
+
+class Injector(object):
+    """Class for injections dll"""
+
+    def __init__(self, pid, backend_name, dll_name, is_unicode=False):
+        """Constructor inject dll (one application - one class instance)."""
+        self.is_unicode = is_unicode
+        self.pid = pid
+        if not sysinfo.is_x64_python() == sysinfo.is64_bitprocess(self.pid):
+            raise RuntimeError("Application and Python must be both 32-bit or both 64-bit")
+        self.h_process = self._get_process_handle(self.pid)
+
+        self.dll_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                     'libs', backend_name,
+                                     'x{}'.format("64" if sysinfo.is64_bitprocess(self.pid) else "86"),
+                                     '{}.dll'.format(dll_name)).encode('utf-16' if self.is_unicode
+                                                                       else locale.getpreferredencoding())
+        self._inject_dll_to_process()
+
+    @staticmethod
+    def _get_process_handle(pid):
+        return cfuncs.OpenProcess(cfuncs.PROCESS_ALL_ACCESS, False, pid)
+
+    def _create_remote_thread_with_timeout(self, proc_address, arg_address, timeout_ms=1000,
+                                           call_err_text="", timeout_err_text=""):
+        thread_handle = cfuncs.CreateRemoteThread(self.h_process, None, 0, proc_address, arg_address, 0, None)
+        if not thread_handle:
+            raise RuntimeError(call_err_text)
+        # TODO: add timeout to pywinauto timings and replace
+        ret = cfuncs.WaitForSingleObject(thread_handle, ctypes.wintypes.DWORD(timeout_ms))
+        if ret == cfuncs.WAIT_TIMEOUT:
+            raise TimeoutError(timeout_err_text)
+
+    def _inject_dll_to_process(self):
+        # Get dll path length
+        c_dll_path = ctypes.create_unicode_buffer(self.dll_path) \
+            if self.is_unicode else ctypes.create_string_buffer(self.dll_path)
+
+        # Allocate space for DLL path
+        arg_address = cfuncs.VirtualAllocEx(self.h_process, 0, ctypes.sizeof(c_dll_path),
+                                            cfuncs.VIRTUAL_MEM, cfuncs.PAGE_READWRITE)
+
+        # Write DLL path to allocated space
+        if not cfuncs.WriteProcessMemory(self.h_process, arg_address,
+                                         ctypes.byref(c_dll_path), ctypes.sizeof(c_dll_path), 0):
+            raise AttributeError("Couldn't write data to process memory, check python access.")
+
+        # Resolve LoadLibraryA(W) Address
+        h_kernel32 = cfuncs.GetModuleHandleW(b"kernel32.dll") \
+            if self.is_unicode else cfuncs.GetModuleHandleA(b"kernel32.dll")
+        h_loadlib = cfuncs.GetProcAddress(h_kernel32, b"LoadLibraryW" if self.is_unicode else b"LoadLibraryA")
+
+        # Now call createRemoteThread with entry point set to LoadLibraryA(W) and pointer to DLL path as param
+        self._create_remote_thread_with_timeout(h_loadlib, arg_address, 1000,
+                                                "Couldn't create remote thread, application and Python must be "
+                                                "both 32-bit or both 64-bit", "Inject time out")
+
+    def _get_dll_proc_address(self, proc_name):
+        lib = cfuncs.LoadLibraryW(self.dll_path) if self.is_unicode else cfuncs.LoadLibraryA(self.dll_path)
+        return cfuncs.GetProcAddress(lib, proc_name)
+
+    def remote_call_void_func(self, func_name):
+        proc_address = self._get_dll_proc_address(func_name)
+
+        if not cfuncs.CreateRemoteThread(self.h_process, None, 0, proc_address, 0, 0, None):
+            raise RuntimeError("Couldn't create remote thread, dll not injected, inject and try again!")
+
+    def remote_call_int_param_func(self, func_name, param):
+        # Resolve param type for different applications
+        a = ctypes.c_int64(param) if sysinfo.is64_bitprocess(self.pid) else ctypes.c_int32(param)
+
+        arg_address = cfuncs.VirtualAllocEx(self.h_process, 0, ctypes.sizeof(a),
+                                            cfuncs.VIRTUAL_MEM, cfuncs.PAGE_READWRITE)
+        if not cfuncs.WriteProcessMemory(self.h_process, arg_address, ctypes.byref(a), ctypes.sizeof(a), 0):
+            raise AttributeError("Couldn't write data to process memory, check python access.")
+
+        proc_address = self._get_dll_proc_address(func_name)
+
+        self._create_remote_thread_with_timeout(proc_address, arg_address, 1000,
+                                                "Couldn't create remote thread, dll not injected, "
+                                                "inject it and try again!",
+                                                "{0}(int) function call time out".format(func_name))

injectlib/sysinfo.py

@@ -0,0 +1,61 @@
+"""Simple module for checking whether Python and Windows are 32-bit or 64-bit"""
+import sys
+import os
+import platform
+import ctypes
+import win32process
+import win32api
+import win32con
+
+
+def os_arch():
+    architecture_map = {
+        'x86': 'x86',
+        'i386': 'x86',
+        'i486': 'x86',
+        'i586': 'x86',
+        'i686': 'x86',
+        'x64': 'x86_64',
+        'AMD64': 'x86_64',
+        'amd64': 'x86_64',
+        'em64t': 'x86_64',
+        'EM64T': 'x86_64',
+        'x86_64': 'x86_64',
+        'IA64': 'ia64',
+        'ia64': 'ia64'
+    }
+    if sys.platform == 'win32':
+        architecture_var = os.environ.get('PROCESSOR_ARCHITEW6432', '')
+        if architecture_var == '':
+            architecture_var = os.environ.get('PROCESSOR_ARCHITECTURE', '')
+        return architecture_map.get(architecture_var, 'Unknown')
+    else:
+        return architecture_map.get(platform.machine(), '')
+
+
+def python_bitness():
+    return ctypes.sizeof(ctypes.POINTER(ctypes.c_int)) * 8
+
+
+def is_x64_python():
+    return python_bitness() == 64
+
+
+def is_x64_os():
+    return os_arch() in ['x86_64', 'ia64']
+
+
+def is64_bitprocess(process_id):
+    """Return True if the specified process is a 64-bit one
+
+    Return False if it is only a 32-bit process running under Wow64.
+    Always return False for x86.
+    """
+
+    if is_x64_os():
+        phndl = win32api.OpenProcess(win32con.MAXIMUM_ALLOWED, 0, process_id)
+        if not phndl:
+            raise OSError(f'OpenProcess is failed for PID = {process_id}')
+        return not win32process.IsWow64Process(phndl)
+
+    return False

injectlib-0.0.1.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: injectlib
+Version: 0.0.1
+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
+Author-email: vasily.v.ryabov@gmail.com
+License: BSD 3-clause
+Keywords: windows gui .net inject testing test desktop dll wpf qt
+Platform: win32
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: pywin32
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+It allows to inject DLls into applications for the Microsoft Windows.

injectlib-0.0.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+injectlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+injectlib/api.py,sha256=JjHgMkUptTZ50MD9iZyYLO6SgmdypAIIs9Kemc-EyVk,2620
+injectlib/cfuncs.py,sha256=Q4xgmRJwrcFF44QXg3ASP1IyUdzTJY0Buabq0lPeJLs,2700
+injectlib/channel.py,sha256=DUGmQAEPWypptNgmI9YTBqkWpVN51hoRCuIq-Vij-sA,2487
+injectlib/injector.py,sha256=qvSd7SBCHbBu8rzuNcupVYy29vAdGRwCEB7Q8agID8U,4854
+injectlib/sysinfo.py,sha256=yNGGlU1GYWiavJWpo41DZyB1jfXl-63zTeRBZGoAEe4,1641
+injectlib/libs/dotnet/x64/Newtonsoft.Json.dll,sha256=tiSUnfiw46YVP9-3MKfG9JkLZZLuDZIuF4hDPSdmEPM,701992
+injectlib/libs/dotnet/x64/bootstrap.dll,sha256=C7Wzdc5IZCThvCVqK43heK6XjJnWQjIu8nh52ilcyH8,33280
+injectlib/libs/dotnet/x64/worker_wpf.dll,sha256=FIyXcT1AAnoVCOzSYE6plM58qSzawoFWi4Oo7stxR78,44032
+injectlib/libs/dotnet/x86/Newtonsoft.Json.dll,sha256=tiSUnfiw46YVP9-3MKfG9JkLZZLuDZIuF4hDPSdmEPM,701992
+injectlib/libs/dotnet/x86/bootstrap.dll,sha256=gIZm6b0SRUSrta-2cMeBtaq5uHkhqf-Z4cmqj5zw5f4,26112
+injectlib/libs/dotnet/x86/worker_wpf.dll,sha256=O37VXoHzxUK3YSdfBIsFyTJMrgbx2bGy2pgbuJ_-EiQ,44544
+injectlib/libs/hook/x64/pywinmsg64.dll,sha256=kzQoE6evywmIOhI7On--ntISTKBgHVRplfQNJ9kpqmA,20480
+injectlib/libs/hook/x64/pywinmsg64u.dll,sha256=0Yi3QsnbZJkEKLk8tzgWZEHtTL4LRZqtScd4rGcnVGg,45056
+injectlib/libs/hook/x86/pywinmsg32.dll,sha256=G1JidmQK4wNDHDeF5DtgjERg_tmMyIaDWmTpvy2IHmA,36864
+injectlib/libs/hook/x86/pywinmsg32u.dll,sha256=4vbB3lQXGny6zy9P-6hSyMzSPT8NAv1ERew_KsJ2Tfg,36864
+injectlib/libs/qt/x64/qt_srv.dll,sha256=7EAldJ48u2uTtzR3A501yXU943UJvHVj4CeqCcGfbRI,76288
+injectlib-0.0.1.dist-info/licenses/LICENSE,sha256=WzT-MnvTQkd_NDKvfKi7ZiDYosFzqKfEt_rWh7oxPg4,1650
+injectlib-0.0.1.dist-info/METADATA,sha256=5SeppRdVeLQzS5oV6PcGc4zggKfK0vOw5LKxUk28uy4,1562
+injectlib-0.0.1.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+injectlib-0.0.1.dist-info/top_level.txt,sha256=_cnZuwXRGkD8hyZ8IT3_9k6_k8DZQe4fQejUz1KaBUM,10
+injectlib-0.0.1.dist-info/RECORD,,

injectlib-0.0.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

injectlib-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,30 @@
+BSD 3-Clause License
+
+Copyright (c) 2026 Vasily Ryabov, Ilya Naumov, Boris Galochkin, Alexander Makarov
+https://github.com/pywinauto/injectlib/graphs/contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

injectlib-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+injectlib