injectlib 0.0.1__tar.gz

injectlib-0.0.1/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/MANIFEST.in

@@ -0,0 +1,16 @@
+include src/injectlib/libs/dotnet/x86/bootstrap.dll
+include src/injectlib/libs/dotnet/x86/Newtonsoft.Json.dll
+include src/injectlib/libs/dotnet/x86/worker_wpf.dll
+
+include src/injectlib/libs/dotnet/x64/bootstrap.dll
+include src/injectlib/libs/dotnet/x64/Newtonsoft.Json.dll
+include src/injectlib/libs/dotnet/x64/worker_wpf.dll
+
+
+include src/injectlib/libs/hook/x86/pywinmsg32.dll
+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

injectlib-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,84 @@
+# injectlib
+
+injectlib is a Python package that allows you to inject DLLs into running
+processes on Windows (32 or 64-bit).
+
+This can be useful for various tasks, such as debugging or adding
+functionality to existing applications.
+
+This is initially created for desktop GUI automation purpose
+(project pywinauto), because an injected DLL can access GUI widgets' text
+properties with much better 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.
+
+It contains:
+
+* initial DLL to be injected which is written in C,
+* server-side DLL that can exchange data between injected DLL (server) and
+Python process (client),
+* managed DLL which is able to get text properties of WPF applications,
+* DLL which is able to get text properties of Qt applications,
+* Python code to initiate the injection,
+* and client Python code for data exchange with an injected DLL.
+
+Link to PyPi: <https://pypi.org/project/injectlib/>
+
+## How to use
+
+    python.exe example_injector.py \<Process name\> \<path to dll\> 
+
+## Development
+
+ 1. Clone repository: <https://github.com/pywinauto/injectlib.git>
+ 2. Create new features or improve exiting (for the injectlib package)
+ 3. After work run setup.py from project root to check standalone
+
+        python.exe setup.py bdist_wheel
+
+## Requirements
+
+### For use as package
+
+* Python >= 3.7
+* pywin32 >= 306
+
+### For development purpose
+
+* setuptools >= 65.5.1
+* wheel >= 0.38.4
+* .NET Framework Targeting Pack >= 4.8
+* .NET Compiler Platform
+* MSBuild
+* MSVC >= 143
+* cmake >= 3.26.3
+* Qt >= 5.15.2, < 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.
+
+- **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.
+
+Once installed, point CMake to your Qt installation by setting `CMAKE_PREFIX_PATH`:
+
+```bash
+# Windows (adjust version/compiler as needed)
+set CMAKE_PREFIX_PATH=C:/Qt/5.15.2/msvc2019_64
+```
+
+If CMake still cannot find Qt, verify the path contains a `lib/cmake/Qt5` subdirectory.
+
+## License
+
+This software is open-source under the BSD 3-Clause License.
+
+See the LICENSE file in this repository.
+
+Dependencies are licensed by their own licenses.

injectlib-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

injectlib-0.0.1/setup.py

@@ -0,0 +1,95 @@
+"""Install and build injectlib distributions"""
+
+import os
+import shutil
+import subprocess
+import sys
+from setuptools import setup
+from setuptools.command.sdist import sdist
+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_64bit = sys.maxsize > 2**32
+if is_64bit:
+    arch_names_map = { x64_cmake_arch_name: x64_package_arch_name }
+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/']
+cmake_dirs = build_dll_dirs
+
+
+class SdistWithDlls(sdist):
+    """Custom build command that compiles DLLs before packaging Python files."""
+
+    def run(self):
+        # cmake build for DLLs
+        for arch in arch_names_map:
+            for cmake_dir in cmake_dirs:
+                build_dir = cmake_dir + build_dirname + arch
+
+                os.makedirs(build_dir, exist_ok=True)
+
+                subprocess.check_call(['cmake', '-B ' + build_dir, '-S ' + cmake_dir, '-A ' + arch])
+                subprocess.check_call(['cmake', '--build', build_dir, '--config', 'Release'])
+
+        # copy DLLs to the package
+        for arch in arch_names_map:
+            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'):
+                            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)
+                            shutil.copy(src_file_path, dest_file_path)
+        super().run()
+
+# mark the package is not pure Python code
+class BinaryDistribution(Distribution):
+    def is_pure(self):
+        return False
+
+
+setup(name='injectlib',
+      version='0.0.1',
+      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",
+      author='Vasily Ryabov, Ilya Naumov, Boris Galochkin, Alexander Makarov',
+      author_email='vasily.v.ryabov@gmail.com',
+      long_description="""
+It allows to inject DLls into applications for the Microsoft Windows.
+""",
+      platforms=['win32'],
+
+      packages=["injectlib"],
+      package_dir={"": "src"},
+      include_package_data=True,
+
+      license="BSD 3-clause",
+      classifiers=[
+          'Development Status :: 5 - Production/Stable',
+          'Environment :: Console',
+          'Intended Audience :: Developers',
+          'License :: OSI Approved :: BSD License',
+          'Operating System :: Microsoft :: Windows',
+          'Programming Language :: Python',
+          'Programming Language :: Python :: 3.7',
+          'Programming Language :: Python :: 3.8',
+          'Programming Language :: Python :: 3.9',
+          'Programming Language :: Python :: 3.10',
+          'Programming Language :: Python :: 3.11',
+          'Programming Language :: Python :: Implementation :: CPython',
+          'Topic :: Software Development :: Libraries :: Python Modules',
+          'Topic :: Software Development :: Testing',
+      ],
+      install_requires=['pywin32'],
+      python_requires='>=3.7',
+      cmdclass={'sdist': SdistWithDlls},
+      )

injectlib-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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/src/injectlib.egg-info/PKG-INFO

@@ -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/src/injectlib.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+src/injectlib/__init__.py
+src/injectlib/api.py
+src/injectlib/cfuncs.py
+src/injectlib/channel.py
+src/injectlib/injector.py
+src/injectlib/sysinfo.py
+src/injectlib.egg-info/PKG-INFO
+src/injectlib.egg-info/SOURCES.txt
+src/injectlib.egg-info/dependency_links.txt
+src/injectlib.egg-info/requires.txt
+src/injectlib.egg-info/top_level.txt
+src/injectlib/libs/dotnet/x64/Newtonsoft.Json.dll
+src/injectlib/libs/dotnet/x64/bootstrap.dll
+src/injectlib/libs/dotnet/x64/worker_wpf.dll
+src/injectlib/libs/dotnet/x86/Newtonsoft.Json.dll
+src/injectlib/libs/dotnet/x86/bootstrap.dll
+src/injectlib/libs/dotnet/x86/worker_wpf.dll
+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

injectlib-0.0.1/src/injectlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

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

injectlib-0.0.1/src/injectlib.egg-info/top_level.txt

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