reykit 1.0.0__py3-none-any.whl

reykit/rdata.py

@@ -0,0 +1,395 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2022-12-05 14:10:42
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Data methods.
+"""
+
+
+from typing import Any, TypedDict, Optional, Literal, NoReturn, TypeVar, overload
+from collections.abc import Callable, Iterable, Generator
+
+from .rexception import check_least_one, check_most_one
+from .rsystem import is_iterable
+
+
+__all__ = (
+    'count',
+    'flatten',
+    'split',
+    'unique',
+    'in_arrs',
+    'objs_in',
+    'RGenerator'
+)
+
+
+CountResult = TypedDict('CountResult', {'value': Any, 'count': int})
+Element = TypeVar('Element')
+
+
+def count(
+    data: Iterable,
+    ascend: bool = False
+) -> list[CountResult]:
+    """
+    Group count data element value.
+
+    Parameters
+    ----------
+    data : Data.
+    ascend : Whether ascending by count, otherwise descending order.
+
+    Returns
+    -------
+    Count result.
+
+    Examples
+    --------
+    >>> count([1, True, 1, '1', (2, 3)])
+    [{'value': 1, 'count': 2}, {'value': True, 'count': 1}, {'value': '1', 'count': 1}, {'value': (2, 3), 'count': 1}]
+    """
+
+    # Set parameter.
+    value_list = []
+    count_list = []
+
+    # Count.
+    for element in data:
+        for index, value in enumerate(value_list):
+            element_str = str(element)
+            value_str = str(value)
+            if element_str == value_str:
+                count_list[index] += 1
+                break
+        else:
+            value_list.append(element)
+            count_list.append(1)
+
+    # Convert.
+    result = [
+        {
+            'value': value,
+            'count': count
+        }
+        for value, count in zip(value_list, count_list)
+    ]
+
+    # Sort.
+    result.sort(
+        key=lambda info: info['count'],
+        reverse=not ascend
+    )
+
+    return result
+
+
+def flatten(data: Any, *, _flattern_data: Optional[list] = None) -> list:
+    """
+    Flatten data.
+
+    Parameters
+    ----------
+    data : Data.
+    _flattern_data : Recursion cumulative data.
+
+    Returns
+    -------
+    Data after flatten.
+    """
+
+    # Handle parameter.
+    _flattern_data = _flattern_data or []
+
+    # Flatten.
+
+    ## Recursion dict object.
+    if data.__class__ == dict:
+        for element in data.values():
+            _flattern_data = flatten(
+                element,
+                _flattern_data = _flattern_data
+            )
+
+    ## Recursion iterator.
+    elif is_iterable(data):
+        for element in data:
+            _flattern_data = flatten(
+                element,
+                _flattern_data = _flattern_data
+            )
+
+    ## Other.
+    else:
+        _flattern_data.append(data)
+
+    return _flattern_data
+
+
+@overload
+def split(data: Iterable[Element], share: None = None, bin_size: None = None) -> NoReturn: ...
+
+@overload
+def split(data: Iterable[Element], share: int = None, bin_size: int = None) -> NoReturn: ...
+
+@overload
+def split(data: Iterable[Element], share: Optional[int] = None, bin_size: Optional[int] = None) -> list[list[Element]]: ...
+
+def split(data: Iterable[Element], share: Optional[int] = None, bin_size: Optional[int] = None) -> list[list[Element]]:
+    """
+    Split data into multiple data.
+
+    Parameters
+    ----------
+    data : Data.
+    share : Number of split share.
+    bin_size : Size of each bin.
+
+    Returns
+    -------
+    Split data.
+    """
+
+    # Check parameter.
+    check_least_one(share, bin_size)
+    check_most_one(share, bin_size)
+
+    # Handle parameter.
+    data = list(data)
+
+    # Split.
+    data_len = len(data)
+    _data = []
+    _data_len = 0
+
+    ## by number of share.
+    if share is not None:
+        average = data_len / share
+        for n in range(share):
+            bin_size = int(average * (n + 1)) - int(average * n)
+            _data = data[_data_len:_data_len + bin_size]
+            _data.append(_data)
+            _data_len += bin_size
+
+    ## By size of bin.
+    elif bin_size is not None:
+        while True:
+            _data = data[_data_len:_data_len + bin_size]
+            _data.append(_data)
+            _data_len += bin_size
+            if _data_len > data_len:
+                break
+
+    return _data
+
+
+def unique(data: Iterable[Element]) -> list[Element]:
+    """
+    De duplication of data.
+
+    Parameters
+    ----------
+    data : Data.
+
+    Returns
+    -------
+    List after de duplication.
+    """
+
+    # Handle parameter.
+    data = tuple(data)
+
+    # Delete duplicate.
+    data_unique = list(set(data))
+    data_unique.sort(key=data.index)
+    return data_unique
+
+
+def in_arrs(ojb: Any, *arrs: Iterable, mode: Literal['or', 'and'] = 'or') -> bool:
+    """
+    Judge whether the one object is in multiple arrays.
+
+    Parameters
+    ----------
+    obj : One object.
+    arrs : Multiple arrays.
+    mode : Judge mode.
+        - `Literal['or']`: Judge whether the in a certain array.
+        - `Literal['and']`: Judge whether the in all arrays.
+
+    Returns
+    -------
+    Judge result.
+    """
+
+    # Judge.
+    match mode:
+
+        ## Or.
+        case 'or':
+            for arr in arrs:
+                if ojb in arr:
+                    return True
+
+            return False
+
+        ## And.
+        case 'and':
+            for arr in arrs:
+                if ojb not in arr:
+                    return False
+
+            return True
+
+
+def objs_in(arr: Iterable, *objs: Any, mode: Literal['or', 'and'] = 'or') -> bool:
+    """
+    Judge whether the multiple objects is in one array.
+
+    Parameters
+    ----------
+    arr : One array.
+    objs : Multiple objects.
+    mode : Judge mode.
+        - `Literal['or']`: Judge whether contain a certain object.
+        - `Literal['and']`: Judge whether contain all objects.
+
+    Returns
+    -------
+    Judge result.
+    """
+
+    # Judge.
+    match mode:
+
+        ## Or.
+        case 'or':
+            for obj in objs:
+                if obj in arr:
+                    return True
+
+            return False
+
+        ## And.
+        case 'and':
+            for obj in objs:
+                if obj not in arr:
+                    return False
+
+            return True
+
+
+class RGenerator(object):
+    """
+    Rey's `generator` type.
+    """
+
+
+    def __init__(
+        self,
+        func: Callable,
+        *args: Any,
+        **kwargs: Any
+    ) -> None:
+        """
+        Build `generator` attributes.
+
+        Parameters
+        ----------
+        func : Generate function.
+        args : Function default position arguments.
+        kwargs : Function default keyword arguments.
+        """
+
+        # Set attribute.
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.params: list[tuple[tuple, dict]] = []
+        self.generator = self._generator()
+
+
+    def _generator(self) -> Generator[Any, Any, None]:
+        """
+        Create generator.
+
+        Parameters
+        ----------
+        Generator.
+        """
+
+        # Loop.
+        while True:
+
+            # Break.
+            if self.params == []:
+                break
+
+            # Generate.
+            args, kwargs = self.params.pop(0)
+            result = self.func(*args, **kwargs)
+
+            # Return.
+            yield result
+
+
+    def add(
+        self,
+        *args: Any,
+        **kwargs: Any
+    ) -> None:
+        """
+        Add once generate.
+
+        Parameters
+        ----------
+        args : Function position arguments.
+        kwargs : Function keyword arguments.
+        """
+
+        # Set parameter.
+        func_args = (
+            *self.args,
+            *args
+        )
+        func_kwargs = {
+            **self.kwargs,
+            **kwargs
+        }
+
+        # Add.
+        item = (
+            func_args,
+            func_kwargs
+        )
+        self.params.append(item)
+
+
+    __call__ = add
+
+
+    def __next__(self) -> Any:
+        """
+        Generate once from generator.
+
+        Returns
+        -------
+        Generate value.
+        """
+
+        # Generate.
+        result = next(self.generator)
+
+        return result
+
+
+    def __iter__(self) -> Generator[Any, Any, None]:
+        """
+        Iterating generator.
+        """
+
+        # Iterating.
+        return self.generator

reykit/rdll/__init__.py

@@ -0,0 +1,17 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2023-12-06 16:14:11
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : DLL file methods.
+
+Modules
+-------
+rdll_inject_core : DLL file inject method code.
+rdll_inject : DLL file inject method.
+"""
+
+
+from .rdll_inject import *

reykit/rdll/rdll_inject.py

@@ -0,0 +1,41 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2023-12-06 16:09:59
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : Inject DLL file methods.
+"""
+
+
+__all__ = (
+    'inject_dll',
+)
+
+
+def inject_dll(
+    id_: int,
+    path: str
+) -> None:
+    """
+    Inject DLL file.
+
+    Parameters
+    ----------
+    id_ : Process ID.
+    path : DLL file path.
+    """
+
+
+    from ctypes import create_string_buffer
+
+    from .rdll_inject_core import InjectDLL
+
+
+    # Get parameter.
+    path_bytes = path.encode()
+    buffer = create_string_buffer(path_bytes)
+
+    # Inject.
+    InjectDLL(id_, buffer)

reykit/rdll/rdll_inject_core.py

@@ -0,0 +1,202 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+@Time    : 2023-12-06 16:17:04
+@Author  : Rey
+@Contact : reyxbo@163.com
+@Explain : DLL file inject method code.
+"""
+
+
+import ctypes
+from ctypes.wintypes import (
+    HANDLE,
+    LPVOID,
+    DWORD,
+    BOOL,
+    LPCVOID,
+    HMODULE,
+    LPCSTR,
+    LPDWORD
+)
+import enum
+
+
+def LPVOID_errcheck(result, func, args):
+    if not result:
+        raise ctypes.WinError()
+    return result
+
+
+def Win32API_errcheck(result, func, args):
+    if not result:
+        raise ctypes.WinError()
+
+
+class SECURITY_ATTRIBUTES(ctypes.Structure):
+    _fields_ = [
+        ('nLength', DWORD),
+        ('lpSecurityDescriptor', LPVOID),
+        ('bInheritHandle', BOOL)
+    ]
+
+
+INFINITE = ctypes.c_uint(-1)
+SIZE_T = ctypes.c_size_t
+FARPROC = ctypes.CFUNCTYPE(ctypes.c_int, LPVOID)
+LPTHREAD_START_ROUTINE = ctypes.CFUNCTYPE(DWORD, LPVOID)
+
+VirtualAllocEx = ctypes.windll.kernel32.VirtualAllocEx
+VirtualAllocEx.argtypes = [HANDLE, LPVOID, SIZE_T, DWORD, DWORD]
+VirtualAllocEx.restype = LPVOID
+VirtualAllocEx.errcheck = LPVOID_errcheck
+
+VirtualFreeEx = ctypes.windll.kernel32.VirtualFreeEx
+VirtualFreeEx.argtypes = [HANDLE, LPVOID, SIZE_T, DWORD]
+VirtualFreeEx.restype = BOOL
+VirtualFreeEx.errcheck = Win32API_errcheck
+
+WriteProcessMemory = ctypes.windll.kernel32.WriteProcessMemory
+WriteProcessMemory.argtypes = [HANDLE, LPVOID, LPCVOID, SIZE_T, ctypes.POINTER(SIZE_T)]
+WriteProcessMemory.restype = BOOL
+WriteProcessMemory.errcheck = Win32API_errcheck
+
+GetProcAddress = ctypes.windll.kernel32.GetProcAddress
+GetProcAddress.argtypes = [HMODULE, LPCSTR]
+GetProcAddress.restype = FARPROC
+
+OpenProcess = ctypes.windll.kernel32.OpenProcess
+OpenProcess.argtypes = [DWORD, BOOL, DWORD]
+OpenProcess.restype = HANDLE
+OpenProcess.errcheck = LPVOID_errcheck
+
+GetModuleHandleA = ctypes.windll.kernel32.GetModuleHandleA
+GetModuleHandleA.argtypes = [LPCSTR]
+GetModuleHandleA.restype = HMODULE
+GetModuleHandleA.errcheck = LPVOID_errcheck
+
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+CloseHandle.argtypes = [HANDLE]
+CloseHandle.restype = BOOL
+CloseHandle.errcheck = Win32API_errcheck
+
+LPSECURITY_ATTRIBUTES = ctypes.POINTER(SECURITY_ATTRIBUTES)
+CreateRemoteThread = ctypes.windll.kernel32.CreateRemoteThread
+CreateRemoteThread.argtypes = [HANDLE, LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD]
+CreateRemoteThread.restype = HANDLE
+CreateRemoteThread.errcheck = LPVOID_errcheck
+
+WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject
+WaitForSingleObject.argtypes = [HANDLE, DWORD]
+WaitForSingleObject.restype = DWORD
+
+GetExitCodeThread = ctypes.windll.kernel32.GetExitCodeThread
+GetExitCodeThread.argtypes = [HANDLE, LPDWORD]
+GetExitCodeThread.restype = BOOL
+GetExitCodeThread.errcheck = Win32API_errcheck
+
+
+class Process(enum.IntFlag):
+    CREATE_PROCESS = 0x0080
+    CREATE_THREAD = 0x0002
+    DUP_HANDLE = 0x0002
+    QUERY_INFORMATION = 0x0400
+    QUERY_LIMITED_INFORMATION = 0x1000
+    SET_INFORMATION = 0x0200
+    SET_QUOTA = 0x0100
+    SUSPEND_RESUME = 0x0800
+    TERMINATE = 0x0001
+    VM_OPERATION = 0x0008
+    VM_READ = 0x0010
+    VM_WRITE = 0x0020
+    SYNCHRONIZE = 0x00100000
+
+
+class AllocationType(enum.IntFlag):
+    COMMIT = 0x00001000
+    RESERVE = 0x00002000
+    RESET = 0x00080000
+    RESET_UNDO = 0x1000000
+    LARGE_PAGES = 0x20000000
+    PHYSICAL = 0x00400000
+    TOP_DOWN = 0x00100000
+
+
+class FreeType(enum.IntFlag):
+    COALESCE_PLACEHOLDERS = 0x1
+    PRESERVE_PLACEHOLDER = 0x2
+    DECOMMIT = 0x4000
+    RELEASE = 0x8000
+
+
+class PageProtection(enum.IntFlag):
+    EXECUTE = 0x10
+    EXECUTE_READ = 0x20
+    EXECUTE_READWRITE = 0x40
+    EXECUTE_WRITECOPY = 0x80
+    NOACCESS = 0x01
+    READONLY = 0x02
+    READWRITE = 0x04
+    WRITECOPY = 0x08
+    TARGETS_INVALID = 0x40000000
+    TARGETS_NO_UPDATE = 0x40000000
+    GUARD = 0x100
+    NOCACHE = 0x200
+    WRITECOMBINE = 0x400
+
+
+def InjectDLL(
+    target_pid,
+    filename_dll
+):
+
+    target_handle = OpenProcess(
+        Process.CREATE_THREAD | Process.VM_OPERATION | Process.VM_READ | Process.VM_WRITE,
+        False,
+        target_pid
+    )
+
+    dll_path_addr = VirtualAllocEx(
+        target_handle,
+        None,
+        len(filename_dll),
+        AllocationType.COMMIT | AllocationType.RESERVE,
+        PageProtection.READWRITE
+    )
+
+    WriteProcessMemory(
+        target_handle,
+        dll_path_addr,
+        filename_dll,
+        len(filename_dll),
+        None
+    )
+
+    module_handle = GetModuleHandleA(b'Kernel32')
+    target_LoadLibraryA = GetProcAddress(module_handle, b'LoadLibraryA')
+
+    thread_handle = CreateRemoteThread(
+        target_handle,
+        None,
+        0,
+        ctypes.cast(
+            target_LoadLibraryA,
+            LPTHREAD_START_ROUTINE
+        ),
+        dll_path_addr,
+        0,
+        None
+    )
+
+    WaitForSingleObject(thread_handle, INFINITE)
+
+    exit_code = DWORD()
+    GetExitCodeThread(thread_handle, ctypes.byref(exit_code))
+
+    try:
+        CloseHandle(thread_handle)
+        VirtualFreeEx(thread_handle, dll_path_addr, 0, FreeType.RELEASE)
+        CloseHandle(target_handle)
+    except OSError:
+        pass