{

public:

Timer(size_t interval_ms)

{

this->interval_ms = interval_ms;

timestamp = std::chrono::system_clock::now();

}

void reset()

{

timestamp = std::chrono::system_clock::now();

}

bool has_elapsed()

{

auto now = std::chrono::system_clock::now();

auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(now - timestamp);

if (diff.count() >= interval_ms)

{

return true;

}

return false;

}

private:

size_t interval_ms = 0;

std::chrono::system_clock::time_point timestamp;

{

const std::string log_file_name = get_current_module_name() + "_log.txt";

constexpr size_t failbit = 2;

std::stringstream stream;

if (!logging_enabled)

{

return;

}

stream << get_current_module_name() << " > ";

(stream << ... << args) << std::endl;

std::cout << stream.str();

if (!log_file.fail())

{

if (!log_file.is_open())

{

std::cout << "Log file opened" << std::endl;

log_file.open(log_file_name);

}

if (log_file.is_open())

{

// Stop at a log file size of > 100MB to avoid filling disks

if (std::filesystem::file_size(log_file_name) > 100000000)

{

log_file << "Max log file size reached. Stopping logging.";

log_file.flush();

log_file.setstate(failbit);

}

else

{

log_file << stream.str();

log_file.flush();

}

}

}

{

static std::string current_process_name = "NULL";

if(current_process_name != "NULL")

{

return current_process_name;

}

HMODULE module = NULL;

char lp_filename[MAX_PATH];

GetModuleFileNameA(module, lp_filename, sizeof(lp_filename));

std::string module_name = strrchr(lp_filename, '\\');

current_process_name = module_name.substr(1, module_name.length());

return current_process_name;

{

static std::string current_module_name = "NULL";

if (current_module_name != "NULL")

{

return current_module_name;

}

HMODULE module = NULL;

static char dummy_static_var_to_get_module_handle = 'x';

GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, &dummy_static_var_to_get_module_handle, &module);

char lp_filename[MAX_PATH];

GetModuleFileNameA(module, lp_filename, sizeof(lp_filename));

current_module_name = strrchr(lp_filename, '\\');

current_module_name = current_module_name.substr(1, current_module_name.length());

current_module_name.erase(current_module_name.find(".dll"), current_module_name.length());

return current_module_name;

{

DWORD_PTR base_address = 0;

HANDLE process_handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process_id);

HMODULE* module_array = nullptr;

LPBYTE module_array_bytes = 0;

DWORD bytes_required = 0;

if (process_handle)

{

if (EnumProcessModules(process_handle, NULL, 0, &bytes_required))

{

if (bytes_required)

{

module_array_bytes = (LPBYTE)LocalAlloc(LPTR, bytes_required);

if (module_array_bytes)

{

unsigned int module_count;

module_count = bytes_required / sizeof(HMODULE);

module_array = (HMODULE*)module_array_bytes;

if (EnumProcessModules(process_handle, module_array, bytes_required, &bytes_required))

{

base_address = (DWORD_PTR)module_array[0];

}

LocalFree(module_array_bytes);

}

}

}

CloseHandle(process_handle);

}

return base_address;

{

toggle_memory_protection(false, destination, num_bytes);

toggle_memory_protection(false, source, num_bytes);

memcpy((void*)destination, (void*)source, num_bytes);

toggle_memory_protection(true, source, num_bytes);

toggle_memory_protection(true, destination, num_bytes);

{

toggle_memory_protection(false, address, num_bytes);

memset((void*)address, byte, num_bytes);

toggle_memory_protection(true, address, num_bytes);

{

static std::map<uintptr_t, DWORD> protection_history;

if (enable_protection && protection_history.find(address) != protection_history.end())

{

VirtualProtect((void*)address, size, protection_history[address], &protection_history[address]);

protection_history.erase(address);

}

else if (!enable_protection && protection_history.find(address) == protection_history.end())

{

DWORD old_protection = 0;

VirtualProtect((void*)address, size, PAGE_EXECUTE_READWRITE, &old_protection);

protection_history[address] = old_protection;

}

{

std::vector<std::string> aob_tokens = tokenify_aob_string(aob);

if (!is_aob_valid(aob_tokens))

{

log("AOB is invalid! (" + aob + ")");

return false;

};

return true;

{

for (const auto& aob : aobs)

{

if (!verify_aob(aob))

{

return false;

}

}

return true;

{

for (const auto& byte : aob_tokens)

{

if (byte == "?")

{

continue;

}

if (byte.length() != 2)

{

return false;

}

std::string whitelist = "0123456789abcdef";

if (byte.find_first_not_of(whitelist) != std::string::npos)

{

return false;

}

}

return true;

{

std::vector<std::string> aob1_tokens = tokenify_aob_string(aob1);

std::vector<std::string> aob2_tokens = tokenify_aob_string(aob2);

size_t shortest_aob_length = aob1_tokens.size() < aob2_tokens.size() ? aob1_tokens.size() : aob2_tokens.size();

for (size_t i = 0; i < shortest_aob_length; i++)

{

bool is_token_masked = aob1_tokens[i] == "?" || aob2_tokens[i] == "?";

if (is_token_masked)

{

continue;

}

if (aob1_tokens[i] != aob2_tokens[i])

{

log("Bytes do not match!");

return false;

}

}

return true;

{

std::istringstream iss(aob);

std::vector<std::string> aob_tokens{

std::istream_iterator<std::string>{iss},

std::istream_iterator<std::string>{}

};

return aob_tokens;

{

std::vector<unsigned char> raw_aob;

std::vector<std::string> tokenified_aob = tokenify_aob_string(aob);

for (size_t i = 0; i < tokenified_aob.size(); i++)

{

if (tokenified_aob[i] == "?")

{

log("Cannot convert AOB with mask to raw AOB");

return std::vector<unsigned char>();

}

unsigned char byte = (unsigned char)std::stoul(tokenified_aob[i], nullptr, 16);

raw_aob.push_back(byte);

}

return raw_aob;

{

std::string aob;

for (const auto& byte : raw_aob)

{

std::string string = number_to_hex_string(byte);

aob += string + " ";

}

aob.pop_back();

return aob;

{

if (!verify_aob(aob))

{

return 0;

};

std::vector<std::string> aob_tokens = tokenify_aob_string(aob);

DWORD process_id = GetCurrentProcessId();

uintptr_t region_start = get_process_base_address(process_id);

size_t num_regions_checked = 0;

size_t max_regions_to_check = 10000;

uintptr_t current_address = 0;

while (num_regions_checked < max_regions_to_check)

{

MEMORY_BASIC_INFORMATION memory_info = { 0 };

if (VirtualQuery((void*)region_start, &memory_info, sizeof(MEMORY_BASIC_INFORMATION)) == 0)

{

DWORD error = GetLastError();

if (error == ERROR_INVALID_PARAMETER)

{

log("Reached end of scannable memory.");

}

else

{

log("VirtualQuery failed, error code: ", error);;

}

break;

}

region_start = (uintptr_t)memory_info.BaseAddress;

uintptr_t region_size = (uintptr_t)memory_info.RegionSize;

uintptr_t region_end = region_start + region_size;

uintptr_t protection = (uintptr_t)memory_info.Protect;

uintptr_t state = (uintptr_t)memory_info.State;

bool memory_is_readable =

state == MEM_COMMIT

&& (protection == PAGE_EXECUTE

|| protection == PAGE_EXECUTE_READ

|| protection == PAGE_EXECUTE_READWRITE

|| protection == PAGE_EXECUTE_WRITECOPY

|| protection == PAGE_READONLY

|| protection == PAGE_READWRITE

|| protection == PAGE_WRITECOPY);

if (memory_is_readable)

{

log("Checking region: ", number_to_hex_string(region_start));

current_address = region_start;

while (current_address < region_end - aob_tokens.size())

{

for (size_t i = 0; i < aob_tokens.size(); i++)

{

if (aob_tokens[i] == "?")

{

current_address++;

continue;

}

else if (*(unsigned char*)current_address != (unsigned char)std::stoul(aob_tokens[i], nullptr, 16))

{

current_address++;

break;

}

else if (i == aob_tokens.size() - 1)

{

uintptr_t signature = current_address - aob_tokens.size() + 1;

log("Found signature at ", number_to_hex_string(signature));

return signature;

}

current_address++;

}

}

}

else

{

log("Skipped region: ", number_to_hex_string(region_start));

}

num_regions_checked++;

region_start += memory_info.RegionSize;

}

log("Stopped at: ", number_to_hex_string(current_address), ", num regions checked: ", num_regions_checked);

return 0;

{

std::stringstream stream;

stream

<< std::setfill('0')

<< std::setw(sizeof(T) * 2)

<< std::hex

<< number;

return stream.str();

{

std::stringstream stream;

stream

<< std::setw(2)

<< std::setfill('0')

<< std::hex

<< (unsigned int)number; // The << operator overload for unsigned chars screws us over unless this cast is done

return stream.str();

{

if (!verify_aobs({ expected_bytes, new_bytes }))

{

return false;

}

std::vector<std::string> expected_bytes_tokens = tokenify_aob_string(expected_bytes);

std::vector<unsigned char> existing_bytes_buffer(expected_bytes_tokens.size(), 0);

mem_copy((uintptr_t)&existing_bytes_buffer[0], address, existing_bytes_buffer.size());

std::string existing_bytes = raw_aob_to_string_aob(existing_bytes_buffer);

log("Bytes at address: ", existing_bytes);

log("Expected bytes: ", expected_bytes);

log("New bytes: ", new_bytes);

if (do_aobs_match(existing_bytes, expected_bytes))

{

log("Bytes match");

std::vector<unsigned char> raw_new_bytes = string_aob_to_raw_aob(new_bytes);

mem_copy(address, (uintptr_t)&raw_new_bytes[0], raw_new_bytes.size());

log("Patch applied");

return true;

}

return false;

{

#ifndef _WIN64

hook32(address, destination);

#else

hook64(address, destination);

#endif

log("Created jump from ", number_to_hex_string(address), " to ", number_to_hex_string(destination));

{

constexpr unsigned char jump_byte = 0xe9;

mem_copy(address, (uintptr_t)&jump_byte, 1);

int32_t relative_displacement = calculate_displacement_for_relative_jump(address, destination);

mem_copy(address + 1, (uintptr_t)&relative_displacement, sizeof(uintptr_t));

{

std::vector<unsigned char> jump_bytes = { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00 };

mem_copy(address, (uintptr_t)&jump_bytes[0], jump_bytes.size());

mem_copy((address + 6), (uintptr_t)&destination, sizeof(uintptr_t));

{

constexpr size_t size_of_e9_jump = 5;

return -int32_t(relative_jump_address + size_of_e9_jump - destination_address);

{

uintptr_t absolute_address = 0;

intptr_t relative_address = 0;

mem_copy((uintptr_t)&relative_address, relative_address_location, 4);

absolute_address = relative_address_location + 4 + relative_address;

return absolute_address;

{

static std::vector<std::vector<std::string>> previously_pressed_combinations;

static bool should_attempt_to_get_window_handle = true;

if (should_attempt_to_get_window_handle)

{

get_window_handle();

should_attempt_to_get_window_handle = false;

}

bool input_is_for_another_application = app_window == NULL || app_window != GetForegroundWindow();

if (input_is_for_another_application)

{

return false;

}

size_t pressed_key_count = 0;

for (const auto& key_string : key_combination)

{

bool is_windows_virtual_key_code = string_to_keycode_map.find(key_string) != string_to_keycode_map.end();

if (is_windows_virtual_key_code)

{

unsigned short key_code = string_to_keycode_map.at(key_string);

if (GetAsyncKeyState(key_code))

{

pressed_key_count++;

}

}

else

{

bool is_xinput_key_code = string_to_xinput_keycode_map.find(key_string) != string_to_xinput_keycode_map.end();

if (is_xinput_key_code)

{

for (DWORD controller_index = 0; controller_index < XUSER_MAX_COUNT; controller_index++)

{

XINPUT_STATE state = { 0 };

DWORD result = XInputGetState(controller_index, &state);

if (result == ERROR_SUCCESS) // LOL

{

unsigned short key_code = string_to_xinput_keycode_map.at(key_string);

if ((key_code & state.Gamepad.wButtons) == key_code)

{

pressed_key_count++;

}

}

}

}

else

{

log("Error: Key string does not match a key code");

}

}

}

auto iterator = std::find(previously_pressed_combinations.begin(), previously_pressed_combinations.end(), key_combination);

bool combination_was_previously_pressed = iterator != previously_pressed_combinations.end();

bool all_keys_in_combination_pressed = pressed_key_count == key_combination.size();

if (all_keys_in_combination_pressed)

{

if (combination_was_previously_pressed)

{

if (return_true_while_held)

{

return true;

}

}

else

{

previously_pressed_combinations.push_back(key_combination);

return true;

}

}

else

{

if (combination_was_previously_pressed)

{

previously_pressed_combinations.erase(iterator);

}

}

return false;

{

if (target_window_name == "NULL")

{

log("Target window name not set. Cannot check input.");

return;

}

size_t attempts = 0;

size_t max_attempts = 1000;

while (true)

{

if (attempts >= max_attempts)

{

return;

}

if (get_window_handle_by_window_name())

{

break;

}

else if (get_window_handle_by_enumeration())

{

break;

}

attempts++;

Sleep(10);

}

char buffer[100];

GetWindowTextA(app_window, buffer, 100);

log("Found application window: ", buffer);

{

HWND hwnd = FindWindowExA(NULL, NULL, NULL, target_window_name.c_str());

DWORD process_id = 0;

GetWindowThreadProcessId(hwnd, &process_id);

if (process_id == GetCurrentProcessId())

{

app_window = hwnd;

log("Found window handle by name ", target_window_name);

return true;

}

return false;

{

EnumWindows(&enum_window_handles, NULL);

if (app_window != NULL)

{

return true;

}

return false;

{

DWORD process_id = NULL;

GetWindowThreadProcessId(hwnd, &process_id);

if (process_id == GetCurrentProcessId())

{

char buffer[100];

GetWindowTextA(hwnd, buffer, 100);

bool window_name_matches_target_window_name = std::string(buffer).find(target_window_name) != std::string::npos;

if (window_name_matches_target_window_name)

{

log(buffer, " handle selected");

app_window = hwnd;

return false;

}

}

return true;