def readinto(self, b): bytes_to_be_read = len(b) if not bytes_to_be_read: return 0 elif bytes_to_be_read % 2: raise ValueError( "cannot read odd number of bytes from UTF-16-LE encoded console" ) buffer = get_buffer(b, writable=True) code_units_to_be_read = bytes_to_be_read // 2 code_units_read = c_ulong() set_last_error(ERROR_SUCCESS) ReadConsoleW(self.handle, buffer, code_units_to_be_read, byref(code_units_read), None) last_error = get_last_error() if last_error == ERROR_OPERATION_ABORTED: time.sleep(0.1) # wait for KeyboardInterrupt if last_error != ERROR_SUCCESS: raise WinError(last_error) if buffer[0] == EOF: return 0 else: return 2 * code_units_read.value # bytes read
def rush(enable=True, realtime=False): """Raise the priority of the current thread/process. Set with rush(True) or rush(False) Beware and don't take priority until after debugging your code and ensuring you have a way out (e.g. an escape sequence of keys within the display loop). Otherwise you could end up locked out and having to reboot! """ if enable: gc.disable() else: gc.enable() if importWindllFailed: return False pr_rights = PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION pr = windll.OpenProcess(pr_rights, FALSE, os.getpid()) thr = windll.GetCurrentThread() if enable: if realtime: windll.SetPriorityClass(pr, REALTIME_PRIORITY_CLASS) windll.SetThreadPriority(thr, THREAD_PRIORITY_TIME_CRITICAL) else: windll.SetPriorityClass(pr, HIGH_PRIORITY_CLASS) windll.SetThreadPriority(thr, THREAD_PRIORITY_HIGHEST) else: windll.SetPriorityClass(pr, NORMAL_PRIORITY_CLASS) windll.SetThreadPriority(thr, THREAD_PRIORITY_NORMAL) err = get_last_error() if err: set_last_error(0) return False return True
def write_bytes(process_handle, address, buffer): """Writes a buffer (number of bytes) to a specified address in a process Keyword arguments: process_handle -- handle to process address -- address in process to write to buffer -- a bytearray or bytes object to write at [address] """ c_data = c_char_p(bytes(buffer)) c_data_ = cast(c_data, POINTER(c_char)) __WriteProcessMemory__(process_handle, address, c_data_, len(buffer), None) err = get_last_error() if err: set_last_error(0)
def write_byte(process_handle, address, value): """Writes a single byte at a specified address in a process Keyword arguments: process_handle -- handle to process address -- address in process to write to value -- value to write at [address] """ c_data = c_char_p(struct.pack("B", value)) c_data_ = cast(c_data, POINTER(c_char)) __WriteProcessMemory__(process_handle, address, c_data_, SIZE_CHAR, None) err = get_last_error() if err: set_last_error(0)
def readwcharsinto(self, buf, n): nr = DWORD(n) old_error = ctypes.get_last_error() ctypes.set_last_error(0) success = ReadConsoleW(self.handle, buf, nr, ctypes.byref(nr), ctypes.c_void_p()) error = ctypes.get_last_error() ctypes.set_last_error(old_error) if not success: raise ctypes.WinError(error) ERROR_OPERATION_ABORTED = 995 if nr.value == 0 and error == ERROR_OPERATION_ABORTED: # Apparently this can trigger pending KeyboardInterrupts? time.sleep(1.0 / (1 << 64)) raise KeyboardInterrupt() # If Python doesn't raise it, we can return nr.value
def write_double(process_handle, address, value): """Writes a single double at a specified address in a process Keyword arguments: process_handle -- handle to process address -- address in process to write to value -- value to write at [address] """ c_data = c_char_p(struct.pack("d", value)) c_data_ = cast(c_data, POINTER(c_char)) __wPM__(process_handle, address, c_data_, SIZE_DOUBLE, None) err = get_last_error() if err: set_last_error(0)
def read_double(process_handle, address): """Reads a single double at a specified address from a process Returns an double which is the value at [address] Keyword arguments: process_handle -- handle to process address -- address in process to read from """ buffer = create_string_buffer(SIZE_DOUBLE) bytes_read = c_size_t() __rPM__(process_handle, address, buffer, SIZE_DOUBLE, byref(bytes_read)) err = get_last_error() if err: set_last_error(0) #print(ERR_CODE.get(err, err)) return struct.unpack("d", buffer[0:SIZE_DOUBLE])[0]
def read_short(process_handle, address): """Reads an short at a specified address from a process Returns an short which is the value at [address] Keyword arguments: process_handle -- handle to process address -- address in process to read from """ buffer = create_string_buffer(SIZE_SHORT) bytes_read = c_size_t() __ReadProcessMemory__(process_handle, address, buffer, SIZE_SHORT, byref(bytes_read)) err = get_last_error() if err: set_last_error(0) #print(ERR_CODE.get(err, err)) return struct.unpack("H", buffer[0:SIZE_SHORT])[0]
def read_bytes(process_handle, address, length): """Reads an array of bytes at a specified address from a process Returns a list which is values at [address], with a length of [length] Keyword arguments: process_handle -- handle to process address -- address in process to read from length -- number of bytes to read """ buffer = create_string_buffer(length) bytes_read = c_size_t() __rPM__(process_handle, address, buffer, length, byref(bytes_read)) err = get_last_error() if err: set_last_error(0) #print(ERR_CODE.get(err, err)) return bytearray(buffer[0:length])
def set_owner(hwnd, hwnd_owner): """ Changes the owner window of the given window :param hwnd: :param hwnd_owner: """ _update_window = ctypes.windll.user32.UpdateWindow # WIN32 vs WIN64 - from a macro in winuser.h if ctypes.sizeof(ctypes.wintypes.HWND) == ctypes.sizeof(ctypes.c_long): _LONG = ctypes.wintypes.LONG _set_window_long = ctypes.windll.user32.SetWindowLongW _set_window_long.argtypes = [ ctypes.wintypes.HWND, ctypes.c_int, ctypes.wintypes.LONG ] _set_window_long.restype = ctypes.c_void_p elif ctypes.sizeof(ctypes.wintypes.HWND) == ctypes.sizeof( ctypes.c_longlong): _LONG = ctypes.wintypes.HWND _set_window_long = ctypes.windll.user32.SetWindowLongPtrW _set_window_long.argtypes = [ ctypes.wintypes.HWND, ctypes.c_int, ctypes.wintypes.HWND ] _set_window_long.restype = _LONG last_error = ctypes.set_last_error(0) try: result = _set_window_long(ctypes.wintypes.HWND(hwnd), ctypes.c_int(GWL_HWNDPARENT), _LONG(hwnd_owner)) finally: last_error = ctypes.set_last_error(last_error) if not result and last_error: raise ctypes.WinError(last_error) _update_window(hwnd_owner) return result
def readinto(self, b): bytes_to_be_read = len(b) if not bytes_to_be_read: return 0 elif bytes_to_be_read % 2: raise ValueError("cannot read odd number of bytes from UTF-16-LE encoded console") buffer = get_buffer(b, writable=True) code_units_to_be_read = bytes_to_be_read // 2 code_units_read = c_ulong() set_last_error(ERROR_SUCCESS) ReadConsoleW(self.handle, buffer, code_units_to_be_read, byref(code_units_read), None) last_error = get_last_error() if last_error == ERROR_OPERATION_ABORTED: time.sleep(0.1) # wait for KeyboardInterrupt if last_error != ERROR_SUCCESS: raise WinError(last_error) if buffer[0] == EOF: return 0 else: return 2 * code_units_read.value # bytes read
def priority(level=0, pid=None): # 0 = normal priority # 1 = high # 2 = realtime gc.disable() if level > 0 else gc.enable() if kernel32 is None and avrt is None: # nothing to do if we don't have these return False pid = os.getpid() process = kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION, 0, pid) thread = kernel32.GetCurrentThread() if thread in thread_pool.keys(): thread_grp = thread_pool[thread] else: thread_grp = {'mmcss': None} thread_pool[thread] = thread_grp # if this is a MMCSS scheduled thread, need to revert to normal first if avrt and thread_grp['mmcss']: avrt.AvRevertMmThreadCharacteristics(thread_grp['mmcss']) thread_grp['mmcss'] = None # clear error if anything? err = get_last_error() if err: set_last_error(0) return False if level == 1: kernel32.SetPriorityClass(process, HIGH_PRIORITY_CLASS) if avrt: tmp = LPDWORD() thread_grp['mmcss'] = avrt.AvSetMmMaxThreadCharacteristicsA(LPCSTR(b'Pro Audio'), LPCSTR(b'Capture'), byref(tmp)) if not thread_grp['mmcss']: # failed kernel32.SetThreadPriority(thread, THREAD_PRIORITY_HIGHEST) elif level >= 2: # first try to set time critical if (not kernel32.SetPriorityClass(process, REALTIME_PRIORITY_CLASS) or kernel32.GetPriorityClass(process) != REALTIME_PRIORITY_CLASS): # try for high priority scheduling instead kernel32.SetPriorityClass(process, HIGH_PRIORITY_CLASS) if avrt: tmp = LPDWORD() thread_grp['mmcss'] = avrt.AvSetMmMaxThreadCharacteristicsA(LPCSTR(b'Pro Audio'), LPCSTR(b'Capture'), byref(tmp)) if not thread_grp['mmcss']: # failed kernel32.SetThreadPriority( thread, THREAD_PRIORITY_ABOVE_NORMAL) else: kernel32.SetPriorityClass(process, NORMAL_PRIORITY_CLASS) kernel32.SetThreadPriority(thread, THREAD_PRIORITY_NORMAL) return True