Rim/t8-mod
Rim/t8-mod
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

structural changes

Browse Source
This commit is contained in:
project-bo4 2023-11-10 13:52:20 -08:00
parent 55553a4099
commit e584075243
74 changed files with 604 additions and 411 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
source/proxy-dll/component/arxan.cpp
View File

@ -1,8 +1,8 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
namespace arxan namespace arxan
@ -15,7 +15,7 @@ namespace arxan
{ {
std::vector<std::pair<uint8_t*, size_t>> texts{}; std::vector<std::pair<uint8_t*, size_t>> texts{};
const utils::nt::library game{}; const utilities::nt::library game{};
for (const auto& section : game.get_section_headers()) for (const auto& section : game.get_section_headers())
{ {
if (section->Characteristics & IMAGE_SCN_MEM_EXECUTE) if (section->Characteristics & IMAGE_SCN_MEM_EXECUTE)
@ -95,7 +95,7 @@ namespace arxan
if (!context) if (!context)
{ {
MessageBoxA(nullptr, utils::string::va("No frame offset for: %llX", handler_address), "Error", MessageBoxA(nullptr, utilities::string::va("No frame offset for: %llX", handler_address), "Error",
MB_ICONERROR); MB_ICONERROR);
TerminateProcess(GetCurrentProcess(), 0xBAD); TerminateProcess(GetCurrentProcess(), 0xBAD);
return current_checksum; return current_checksum;
@ -125,11 +125,11 @@ namespace arxan
if ((next_inst & 0xFF00FFFF) != 0xFF004583) if ((next_inst & 0xFF00FFFF) != 0xFF004583)
{ {
throw std::runtime_error(utils::string::va("Unable to patch intact basic block: %llX", game_address)); throw std::runtime_error(utilities::string::va("Unable to patch intact basic block: %llX", game_address));
} }
const auto other_frame_offset = static_cast<uint8_t>(next_inst >> 16); const auto other_frame_offset = static_cast<uint8_t>(next_inst >> 16);
static const auto stub = utils::hook::assemble([](utils::hook::assembler& a) static const auto stub = utilities::hook::assemble([](utilities::hook::assembler& a)
{ {
a.push(rax); a.push(rax);
@ -164,8 +164,8 @@ namespace arxan
}); });
// push other_frame_offset // push other_frame_offset
utils::hook::set<uint16_t>(game_address, static_cast<uint16_t>(0x6A | (other_frame_offset << 8))); utilities::hook::set<uint16_t>(game_address, static_cast<uint16_t>(0x6A | (other_frame_offset << 8)));
utils::hook::call(game_address + 2, stub); utilities::hook::call(game_address + 2, stub);
} }
void patch_split_basic_block_integrity_check(void* address) void patch_split_basic_block_integrity_check(void* address)
@ -177,11 +177,11 @@ namespace arxan
if (*reinterpret_cast<uint8_t*>(next_inst_addr) != 0xE9) if (*reinterpret_cast<uint8_t*>(next_inst_addr) != 0xE9)
{ {
throw std::runtime_error(utils::string::va("Unable to patch split basic block: %llX", game_address)); throw std::runtime_error(utilities::string::va("Unable to patch split basic block: %llX", game_address));
} }
const auto jump_target = utils::hook::extract<void*>(reinterpret_cast<void*>(next_inst_addr + 1)); const auto jump_target = utilities::hook::extract<void*>(reinterpret_cast<void*>(next_inst_addr + 1));
const auto stub = utils::hook::assemble([jump_target](utils::hook::assembler& a) const auto stub = utilities::hook::assemble([jump_target](utilities::hook::assembler& a)
{ {
a.push(rax); a.push(rax);
@ -209,7 +209,7 @@ namespace arxan
a.jmp(jump_target); a.jmp(jump_target);
}); });
utils::hook::call(game_address, stub); utilities::hook::call(game_address, stub);
} }
void search_and_patch_integrity_checks() void search_and_patch_integrity_checks()
@ -235,7 +235,7 @@ namespace arxan
void** get_tls_callbacks() void** get_tls_callbacks()
{ {
const utils::nt::library game{}; const utilities::nt::library game{};
const auto& entry = game.get_optional_header()->DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS]; const auto& entry = game.get_optional_header()->DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS];
if (!entry.VirtualAddress || !entry.Size) if (!entry.VirtualAddress || !entry.Size)
{ {
@ -254,7 +254,7 @@ namespace arxan
original_first_tls_callback = *tls_callbacks; original_first_tls_callback = *tls_callbacks;
} }
utils::hook::set(tls_callbacks, nullptr); utilities::hook::set(tls_callbacks, nullptr);
} }
void restore_tls_callbacks() void restore_tls_callbacks()
@ -262,17 +262,17 @@ namespace arxan
auto* tls_callbacks = get_tls_callbacks(); auto* tls_callbacks = get_tls_callbacks();
if (tls_callbacks) if (tls_callbacks)
{ {
utils::hook::set(tls_callbacks, original_first_tls_callback); utilities::hook::set(tls_callbacks, original_first_tls_callback);
} }
} }
utils::hook::detour create_thread_hook; utilities::hook::detour create_thread_hook;
HANDLE WINAPI create_thread_stub(const LPSECURITY_ATTRIBUTES thread_attributes, const SIZE_T stack_size, HANDLE WINAPI create_thread_stub(const LPSECURITY_ATTRIBUTES thread_attributes, const SIZE_T stack_size,
const LPTHREAD_START_ROUTINE start_address, const LPVOID parameter, const LPTHREAD_START_ROUTINE start_address, const LPVOID parameter,
const DWORD creation_flags, const DWORD creation_flags,
const LPDWORD thread_id) const LPDWORD thread_id)
{ {
if (utils::nt::library::get_by_address(start_address) == utils::nt::library{}) if (utilities::nt::library::get_by_address(start_address) == utilities::nt::library{})
{ {
restore_tls_callbacks(); restore_tls_callbacks();
@ -285,15 +285,15 @@ namespace arxan
creation_flags, thread_id); creation_flags, thread_id);
} }
utils::hook::detour get_thread_context_hook; utilities::hook::detour get_thread_context_hook;
BOOL WINAPI get_thread_context_stub(const HANDLE thread_handle, const LPCONTEXT context) BOOL WINAPI get_thread_context_stub(const HANDLE thread_handle, const LPCONTEXT context)
{ {
constexpr auto debug_registers_flag = (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_AMD64); constexpr auto debug_registers_flag = (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_AMD64);
if (context && (context->ContextFlags & debug_registers_flag)) if (context && (context->ContextFlags & debug_registers_flag))
{ {
auto* source = _ReturnAddress(); auto* source = _ReturnAddress();
const auto game = utils::nt::library{}; const auto game = utilities::nt::library{};
const auto source_module = utils::nt::library::get_by_address(source); const auto source_module = utilities::nt::library::get_by_address(source);
if (source_module == game) if (source_module == game)
{ {
@ -304,7 +304,7 @@ namespace arxan
return get_thread_context_hook.invoke<BOOL>(thread_handle, context); return get_thread_context_hook.invoke<BOOL>(thread_handle, context);
} }
utils::hook::detour create_mutex_ex_a_hook; utilities::hook::detour create_mutex_ex_a_hook;
HANDLE create_mutex_ex_a_stub(const LPSECURITY_ATTRIBUTES attributes, const LPCSTR name, const DWORD flags, HANDLE create_mutex_ex_a_stub(const LPSECURITY_ATTRIBUTES attributes, const LPCSTR name, const DWORD flags,
const DWORD access) const DWORD access)
{ {
@ -405,7 +405,7 @@ namespace arxan
return res; return res;
} }
utils::hook::detour nt_query_system_information_hook; utilities::hook::detour nt_query_system_information_hook;
NTSTATUS NTAPI nt_query_system_information_stub(const SYSTEM_INFORMATION_CLASS system_information_class, NTSTATUS NTAPI nt_query_system_information_stub(const SYSTEM_INFORMATION_CLASS system_information_class,
const PVOID system_information, const PVOID system_information,
const ULONG system_information_length, const ULONG system_information_length,
@ -416,7 +416,7 @@ namespace arxan
if (NT_SUCCESS(status)) if (NT_SUCCESS(status))
{ {
if (system_information_class == SystemProcessInformation && !utils::nt::is_shutdown_in_progress()) if (system_information_class == SystemProcessInformation && !utilities::nt::is_shutdown_in_progress())
{ {
auto addr = static_cast<uint8_t*>(system_information); auto addr = static_cast<uint8_t*>(system_information);
while (true) while (true)
@ -437,7 +437,7 @@ namespace arxan
return status; return status;
} }
utils::hook::detour nt_query_information_process_hook; utilities::hook::detour nt_query_information_process_hook;
NTSTATUS WINAPI nt_query_information_process_stub(const HANDLE handle, const PROCESSINFOCLASS info_class, NTSTATUS WINAPI nt_query_information_process_stub(const HANDLE handle, const PROCESSINFOCLASS info_class,
const PVOID info, const PVOID info,
const ULONG info_length, const PULONG ret_length) const ULONG info_length, const PULONG ret_length)
@ -465,16 +465,16 @@ namespace arxan
disable_tls_callbacks(); disable_tls_callbacks();
create_thread_hook.create(CreateThread, create_thread_stub); create_thread_hook.create(CreateThread, create_thread_stub);
auto* get_thread_context_func = utils::nt::library("kernelbase.dll").get_proc<void*>("GetThreadContext"); auto* get_thread_context_func = utilities::nt::library("kernelbase.dll").get_proc<void*>("GetThreadContext");
get_thread_context_hook.create(get_thread_context_func, get_thread_context_stub); get_thread_context_hook.create(get_thread_context_func, get_thread_context_stub);
create_mutex_ex_a_hook.create(CreateMutexExA, create_mutex_ex_a_stub); create_mutex_ex_a_hook.create(CreateMutexExA, create_mutex_ex_a_stub);
utils::hook::copy(this->window_text_buffer_, GetWindowTextA, sizeof(this->window_text_buffer_)); utilities::hook::copy(this->window_text_buffer_, GetWindowTextA, sizeof(this->window_text_buffer_));
utils::hook::jump(GetWindowTextA, get_window_text_a_stub, true, true); utilities::hook::jump(GetWindowTextA, get_window_text_a_stub, true, true);
utils::hook::move_hook(GetWindowTextA); utilities::hook::move_hook(GetWindowTextA);
const utils::nt::library ntdll("ntdll.dll"); const utilities::nt::library ntdll("ntdll.dll");
const auto nt_query_information_process = ntdll.get_proc<void*>("NtQueryInformationProcess"); const auto nt_query_information_process = ntdll.get_proc<void*>("NtQueryInformationProcess");
nt_query_information_process_hook.create(nt_query_information_process, nt_query_information_process_hook.create(nt_query_information_process,

42
source/proxy-dll/component/blackbox.cpp
View File

@ -2,11 +2,11 @@
#include "definitions/game.hpp" #include "definitions/game.hpp"
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/io.hpp> #include <utilities/io.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
#include <utils/thread.hpp> #include <utilities/thread.hpp>
#include <utils/compression.hpp> #include <utilities/compression.hpp>
#include <exception/minidump.hpp> #include <exception/minidump.hpp>
namespace blackbox namespace blackbox
@ -64,12 +64,12 @@ namespace blackbox
void display_error_dialog() void display_error_dialog()
{ {
const std::string error_str = utils::string::va("Fatal error (0x%08X) at 0x%p (0x%p).\n" const std::string error_str = utilities::string::va("Fatal error (0x%08X) at 0x%p (0x%p).\n"
"A minidump has been written.\n", "A minidump has been written.\n",
exception_data.code, exception_data.address, exception_data.code, exception_data.address,
reverse_b(reinterpret_cast<uint64_t>(exception_data.address))); reverse_b(reinterpret_cast<uint64_t>(exception_data.address)));
utils::thread::suspend_other_threads(); utilities::thread::suspend_other_threads();
show_mouse_cursor(); show_mouse_cursor();
MessageBoxA(nullptr, error_str.data(), "Project-BO4 ERROR", MB_ICONERROR); MessageBoxA(nullptr, error_str.data(), "Project-BO4 ERROR", MB_ICONERROR);
@ -98,7 +98,7 @@ namespace blackbox
size_t get_reset_state_stub() size_t get_reset_state_stub()
{ {
static auto* stub = utils::hook::assemble([](utils::hook::assembler& a) static auto* stub = utilities::hook::assemble([](utilities::hook::assembler& a)
{ {
a.sub(rsp, 0x10); a.sub(rsp, 0x10);
a.or_(rsp, 0x8); a.or_(rsp, 0x8);
@ -165,7 +165,7 @@ namespace blackbox
const auto x64register = [&registers_scroll](const char* key, DWORD64 value) const auto x64register = [&registers_scroll](const char* key, DWORD64 value)
{ {
registers_scroll.append(utils::string::va("\t%s = 0x%llX\r\n", key, value)); registers_scroll.append(utilities::string::va("\t%s = 0x%llX\r\n", key, value));
}; };
x64register("rax", ctx->Rax); x64register("rax", ctx->Rax);
@ -205,7 +205,7 @@ namespace blackbox
for (size_t i = exception_start_index; i < count; i++) for (size_t i = exception_start_index; i < count; i++)
{ {
const auto from = utils::nt::library::get_by_address(backtrace_stack[i]); const auto from = utilities::nt::library::get_by_address(backtrace_stack[i]);
size_t rva = reinterpret_cast<uint64_t>(backtrace_stack[i]) - reinterpret_cast<uint64_t>(from.get_ptr()); size_t rva = reinterpret_cast<uint64_t>(backtrace_stack[i]) - reinterpret_cast<uint64_t>(from.get_ptr());
if (from.get_name() == "BlackOps4.exe"s) rva += 0x140000000; if (from.get_name() == "BlackOps4.exe"s) rva += 0x140000000;
@ -219,7 +219,7 @@ namespace blackbox
std::string generate_crash_info(const LPEXCEPTION_POINTERS exceptioninfo) std::string generate_crash_info(const LPEXCEPTION_POINTERS exceptioninfo)
{ {
const auto& build_info = game::version_string; const auto& build_info = game::version_string;
const auto main_module = utils::nt::library{}; const auto main_module = utilities::nt::library{};
const auto rip_address = exceptioninfo->ExceptionRecord->ExceptionAddress; const auto rip_address = exceptioninfo->ExceptionRecord->ExceptionAddress;
std::string info{}; std::string info{};
@ -231,16 +231,16 @@ namespace blackbox
line(build_info + " Crash Report\r\n"); line(build_info + " Crash Report\r\n");
line(utils::string::va("Exception Code: 0x%08X(%s)", exceptioninfo->ExceptionRecord->ExceptionCode, line(utilities::string::va("Exception Code: 0x%08X(%s)", exceptioninfo->ExceptionRecord->ExceptionCode,
get_exception_string(exceptioninfo->ExceptionRecord->ExceptionCode))); get_exception_string(exceptioninfo->ExceptionRecord->ExceptionCode)));
line(utils::string::va("Exception Addr: 0x%llX[%s]", exceptioninfo->ExceptionRecord->ExceptionAddress, line(utilities::string::va("Exception Addr: 0x%llX[%s]", exceptioninfo->ExceptionRecord->ExceptionAddress,
utils::nt::library::get_by_address(exceptioninfo->ExceptionRecord->ExceptionAddress).get_name().c_str())); utilities::nt::library::get_by_address(exceptioninfo->ExceptionRecord->ExceptionAddress).get_name().c_str()));
line(utils::string::va("Main Module: %s[0x%llX]", main_module.get_name().c_str(), main_module.get_ptr())); line(utilities::string::va("Main Module: %s[0x%llX]", main_module.get_name().c_str(), main_module.get_ptr()));
line(utils::string::va("Thread ID: %d(%s)", GetCurrentThreadId(), is_game_thread() ? "Main Thread" : "Auxiliary Threads")); line(utilities::string::va("Thread ID: %d(%s)", GetCurrentThreadId(), is_game_thread() ? "Main Thread" : "Auxiliary Threads"));
if (exceptioninfo->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) if (exceptioninfo->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
{ {
line(utils::string::va("\r\nExtended Info: Attempted to %s 0x%012X", line(utilities::string::va("\r\nExtended Info: Attempted to %s 0x%012X",
exceptioninfo->ExceptionRecord->ExceptionInformation[0] == 1 ? "write to" : "read from", exceptioninfo->ExceptionRecord->ExceptionInformation[0] == 1 ? "write to" : "read from",
exceptioninfo->ExceptionRecord->ExceptionInformation[1])); exceptioninfo->ExceptionRecord->ExceptionInformation[1]));
} }
@ -256,10 +256,10 @@ namespace blackbox
void write_minidump(const LPEXCEPTION_POINTERS exceptioninfo) void write_minidump(const LPEXCEPTION_POINTERS exceptioninfo)
{ {
const std::string crash_name = utils::string::va("minidumps/shield-crash-%s.zip", const std::string crash_name = utilities::string::va("minidumps/shield-crash-%s.zip",
get_timestamp().data()); get_timestamp().data());
utils::compression::zip::archive zip_file{}; utilities::compression::zip::archive zip_file{};
zip_file.add("crash.dmp", exception::create_minidump(exceptioninfo)); zip_file.add("crash.dmp", exception::create_minidump(exceptioninfo));
zip_file.add("info.txt", generate_crash_info(exceptioninfo)); zip_file.add("info.txt", generate_crash_info(exceptioninfo));
zip_file.write(crash_name, "Project-bo4 Crash Dump"); zip_file.write(crash_name, "Project-bo4 Crash Dump");
@ -304,11 +304,11 @@ namespace blackbox
void pre_start() override void pre_start() override
{ {
const utils::nt::library ntdll("ntdll.dll"); const utilities::nt::library ntdll("ntdll.dll");
auto* set_filter = ntdll.get_proc<void(*)(LPTOP_LEVEL_EXCEPTION_FILTER)>("RtlSetUnhandledExceptionFilter"); auto* set_filter = ntdll.get_proc<void(*)(LPTOP_LEVEL_EXCEPTION_FILTER)>("RtlSetUnhandledExceptionFilter");
set_filter(exception_filter); set_filter(exception_filter);
utils::hook::jump(set_filter, set_unhandled_exception_filter_stub); utilities::hook::jump(set_filter, set_unhandled_exception_filter_stub);
} }
}; };
} }

4
source/proxy-dll/component/debugging.cpp
View File

@ -3,7 +3,7 @@
#include "component/scheduler.hpp" #include "component/scheduler.hpp"
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/string.hpp> #include <utilities/string.hpp>
namespace debugging namespace debugging
{ {
@ -29,7 +29,7 @@ namespace debugging
connectionInfoString[42] = NULL; connectionInfoString[42] = NULL;
return utils::string::va("%s", connectionInfoString); return utilities::string::va("%s", connectionInfoString);
} }
void draw_debug_info() void draw_debug_info()

48
source/proxy-dll/component/demonware.cpp
View File

@ -1,9 +1,9 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/io.hpp> #include <utilities/io.hpp>
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/thread.hpp> #include <utilities/thread.hpp>
#include "demonware/servers/lobby_server.hpp" #include "demonware/servers/lobby_server.hpp"
#include "demonware/servers/auth3_server.hpp" #include "demonware/servers/auth3_server.hpp"
@ -31,8 +31,8 @@ namespace demonware
{ {
std::atomic_bool exit_server{ false }; std::atomic_bool exit_server{ false };
std::thread server_thread{}; std::thread server_thread{};
utils::concurrency::container<std::unordered_map<SOCKET, bool>> blocking_sockets{}; utilities::concurrency::container<std::unordered_map<SOCKET, bool>> blocking_sockets{};
utils::concurrency::container<std::unordered_map<SOCKET, tcp_server*>> socket_map{}; utilities::concurrency::container<std::unordered_map<SOCKET, tcp_server*>> socket_map{};
server_registry<tcp_server> tcp_servers{}; server_registry<tcp_server> tcp_servers{};
server_registry<udp_server> udp_servers{}; server_registry<udp_server> udp_servers{};
std::unordered_map<void*, void*> original_imports{}; std::unordered_map<void*, void*> original_imports{};
@ -153,8 +153,8 @@ namespace demonware
return getaddrinfo(name, service, hints, res); return getaddrinfo(name, service, hints, res);
} }
const auto address = utils::memory::get_allocator()->allocate<sockaddr>(); const auto address = utilities::memory::get_allocator()->allocate<sockaddr>();
const auto ai = utils::memory::get_allocator()->allocate<addrinfo>(); const auto ai = utilities::memory::get_allocator()->allocate<addrinfo>();
auto in_addr = reinterpret_cast<sockaddr_in*>(address); auto in_addr = reinterpret_cast<sockaddr_in*>(address);
in_addr->sin_addr.s_addr = server->get_address(); in_addr->sin_addr.s_addr = server->get_address();
@ -176,13 +176,13 @@ namespace demonware
void freeaddrinfo_stub(addrinfo* ai) void freeaddrinfo_stub(addrinfo* ai)
{ {
if (!utils::memory::get_allocator()->find(ai)) if (!utilities::memory::get_allocator()->find(ai))
{ {
return freeaddrinfo(ai); return freeaddrinfo(ai);
} }
utils::memory::get_allocator()->free(ai->ai_addr); utilities::memory::get_allocator()->free(ai->ai_addr);
utils::memory::get_allocator()->free(ai); utilities::memory::get_allocator()->free(ai);
} }
int getpeername_stub(const SOCKET s, sockaddr* addr, socklen_t* addrlen) int getpeername_stub(const SOCKET s, sockaddr* addr, socklen_t* addrlen)
@ -440,11 +440,11 @@ namespace demonware
void register_hook(const std::string& process, void* stub) void register_hook(const std::string& process, void* stub)
{ {
const utils::nt::library game_module{}; const utilities::nt::library game_module{};
std::optional<std::pair<void*, void*>> result{}; std::optional<std::pair<void*, void*>> result{};
if (!result) result = utils::hook::iat(game_module, "wsock32.dll", process, stub); if (!result) result = utilities::hook::iat(game_module, "wsock32.dll", process, stub);
if (!result) result = utils::hook::iat(game_module, "WS2_32.dll", process, stub); if (!result) result = utilities::hook::iat(game_module, "WS2_32.dll", process, stub);
if (!result) if (!result)
{ {
@ -456,7 +456,7 @@ namespace demonware
void check_lpc_files() void check_lpc_files()
{ {
if (!utils::io::file_exists("LPC/.manifest") || !utils::io::file_exists("LPC/core_ffotd_tu23_639_cf92ecf4a75d3f79.ff") || !utils::io::file_exists("LPC/core_playlists_tu23_639_cf92ecf4a75d3f79.ff")) if (!utilities::io::file_exists("LPC/.manifest") || !utilities::io::file_exists("LPC/core_ffotd_tu23_639_cf92ecf4a75d3f79.ff") || !utilities::io::file_exists("LPC/core_playlists_tu23_639_cf92ecf4a75d3f79.ff"))
{ {
MessageBoxA(nullptr, "some required LPC files seems to be missing. You need to get and place them manually since this emulator doesnt host and provide those files; read instructions in github documentation for more info.", MessageBoxA(nullptr, "some required LPC files seems to be missing. You need to get and place them manually since this emulator doesnt host and provide those files; read instructions in github documentation for more info.",
"LPC Files Missing", MB_ICONERROR); "LPC Files Missing", MB_ICONERROR);
@ -500,18 +500,18 @@ namespace demonware
void post_unpack() override void post_unpack() override
{ {
server_thread = utils::thread::create_named_thread("Demonware", server_main); server_thread = utilities::thread::create_named_thread("Demonware", server_main);
utils::hook::set<uint8_t>(0x144508469_g, 0x0); // CURLOPT_SSL_VERIFYPEER utilities::hook::set<uint8_t>(0x144508469_g, 0x0); // CURLOPT_SSL_VERIFYPEER
utils::hook::set<uint8_t>(0x144508455_g, 0xAF); // CURLOPT_SSL_VERIFYHOST utilities::hook::set<uint8_t>(0x144508455_g, 0xAF); // CURLOPT_SSL_VERIFYHOST
utils::hook::set<uint8_t>(0x144B28D98_g, 0x0); // HTTPS -> HTTP utilities::hook::set<uint8_t>(0x144B28D98_g, 0x0); // HTTPS -> HTTP
utils::hook::copy_string(0x144A27C70_g, "http://prod.umbrella.demonware.net"); utilities::hook::copy_string(0x144A27C70_g, "http://prod.umbrella.demonware.net");
utils::hook::copy_string(0x144A2BAA0_g, "http://prod.uno.demonware.net/v1.0"); utilities::hook::copy_string(0x144A2BAA0_g, "http://prod.uno.demonware.net/v1.0");
utils::hook::copy_string(0x144A29CB0_g, "http://%s:%d/auth/"); utilities::hook::copy_string(0x144A29CB0_g, "http://%s:%d/auth/");
utils::hook::set(0x142DD0E10_g, 0xC301B0); // Live_Qos_Finished utilities::hook::set(0x142DD0E10_g, 0xC301B0); // Live_Qos_Finished
utils::hook::set(0x1438C2C70_g, 0xC301B0); // Live_Contracts? related to bdUNK125 utilities::hook::set(0x1438C2C70_g, 0xC301B0); // Live_Contracts? related to bdUNK125
} }
void pre_destroy() override void pre_destroy() override
@ -524,7 +524,7 @@ namespace demonware
for (const auto& import : original_imports) for (const auto& import : original_imports)
{ {
utils::hook::set(import.first, import.second); utilities::hook::set(import.first, import.second);
} }
} }
}; };

40
source/proxy-dll/component/dvars.cpp
View File

@ -5,7 +5,7 @@
#include "definitions/variables.hpp" #include "definitions/variables.hpp"
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/string.hpp> #include <utilities/string.hpp>
namespace dvars namespace dvars
{ {
@ -25,22 +25,22 @@ namespace dvars
{ {
if (domain.vector.max == FLT_MAX) if (domain.vector.max == FLT_MAX)
{ {
return utils::string::va("Domain is any %iD vector", components); return utilities::string::va("Domain is any %iD vector", components);
} }
else else
{ {
return utils::string::va("Domain is any %iD vector with components %g or smaller", components, return utilities::string::va("Domain is any %iD vector with components %g or smaller", components,
domain.vector.max); domain.vector.max);
} }
} }
else if (domain.vector.max == FLT_MAX) else if (domain.vector.max == FLT_MAX)
{ {
return utils::string::va("Domain is any %iD vector with components %g or bigger", components, return utilities::string::va("Domain is any %iD vector with components %g or bigger", components,
domain.vector.min); domain.vector.min);
} }
else else
{ {
return utils::string::va("Domain is any %iD vector with components from %g to %g", components, return utilities::string::va("Domain is any %iD vector with components from %g to %g", components,
domain.vector.min, domain.vector.max); domain.vector.min, domain.vector.max);
} }
} }
@ -64,16 +64,16 @@ namespace dvars
} }
else else
{ {
return utils::string::va("Domain is any number %g or smaller", domain.value.max); return utilities::string::va("Domain is any number %g or smaller", domain.value.max);
} }
} }
else if (domain.value.max == FLT_MAX) else if (domain.value.max == FLT_MAX)
{ {
return utils::string::va("Domain is any number %g or bigger", domain.value.min); return utilities::string::va("Domain is any number %g or bigger", domain.value.min);
} }
else else
{ {
return utils::string::va("Domain is any number from %g to %g", domain.value.min, domain.value.max); return utilities::string::va("Domain is any number from %g to %g", domain.value.min, domain.value.max);
} }
case game::DVAR_TYPE_FLOAT_2: case game::DVAR_TYPE_FLOAT_2:
@ -97,16 +97,16 @@ namespace dvars
} }
else else
{ {
return utils::string::va("Domain is any integer %i or smaller", domain.integer.max); return utilities::string::va("Domain is any integer %i or smaller", domain.integer.max);
} }
} }
else if (domain.integer.max == INT_MAX) else if (domain.integer.max == INT_MAX)
{ {
return utils::string::va("Domain is any integer %i or bigger", domain.integer.min); return utilities::string::va("Domain is any integer %i or bigger", domain.integer.min);
} }
else else
{ {
return utils::string::va("Domain is any integer from %i to %i", domain.integer.min, domain.integer.max); return utilities::string::va("Domain is any integer from %i to %i", domain.integer.min, domain.integer.max);
} }
case game::DVAR_TYPE_ENUM: case game::DVAR_TYPE_ENUM:
@ -114,7 +114,7 @@ namespace dvars
for (auto string_index = 0; string_index < domain.enumeration.stringCount; ++string_index) for (auto string_index = 0; string_index < domain.enumeration.stringCount; ++string_index)
{ {
str += utils::string::va("\n %2i: %s", string_index, domain.enumeration.strings[string_index]); str += utilities::string::va("\n %2i: %s", string_index, domain.enumeration.strings[string_index]);
} }
return str; return str;
@ -134,16 +134,16 @@ namespace dvars
} }
else else
{ {
return utils::string::va("Domain is any integer %lli or smaller", domain.integer64.max); return utilities::string::va("Domain is any integer %lli or smaller", domain.integer64.max);
} }
} }
else if (domain.integer64.max == _I64_MAX) else if (domain.integer64.max == _I64_MAX)
{ {
return utils::string::va("Domain is any integer %lli or bigger", domain.integer64.min); return utilities::string::va("Domain is any integer %lli or bigger", domain.integer64.min);
} }
else else
{ {
return utils::string::va("Domain is any integer from %lli to %lli", domain.integer64.min, domain.integer64.max); return utilities::string::va("Domain is any integer from %lli to %lli", domain.integer64.min, domain.integer64.max);
} }
case game::DVAR_TYPE_UINT64: case game::DVAR_TYPE_UINT64:
@ -151,12 +151,12 @@ namespace dvars
{ {
if (domain.unsignedInt64.max == _UI64_MAX) if (domain.unsignedInt64.max == _UI64_MAX)
{ {
return utils::string::va("Domain is any unsigned integer %zu or bigger", domain.unsignedInt64.min); return utilities::string::va("Domain is any unsigned integer %zu or bigger", domain.unsignedInt64.min);
} }
else else
{ {
return utils::string::va("Domain is any unsigned integer from %zu to %zu", domain.unsignedInt64.min, domain.unsignedInt64.max); return utilities::string::va("Domain is any unsigned integer from %zu to %zu", domain.unsignedInt64.min, domain.unsignedInt64.max);
} }
} }
else if (domain.unsignedInt64.max == _UI64_MAX) else if (domain.unsignedInt64.max == _UI64_MAX)
@ -165,11 +165,11 @@ namespace dvars
} }
else else
{ {
return utils::string::va("Domain is any integer %zu or smaller", domain.unsignedInt64.max); return utilities::string::va("Domain is any integer %zu or smaller", domain.unsignedInt64.max);
} }
default: default:
return utils::string::va("unhandled dvar type '%i'", type); return utilities::string::va("unhandled dvar type '%i'", type);
} }
} }
@ -265,7 +265,7 @@ namespace dvars
game::dvar_t* find_dvar(const std::string& nameRef) game::dvar_t* find_dvar(const std::string& nameRef)
{ {
auto it = std::find_if(variables::dvars_record.begin(), variables::dvars_record.end(), [&nameRef](variables::varEntry& i) { return utils::string::compare(i.name, nameRef); }); auto it = std::find_if(variables::dvars_record.begin(), variables::dvars_record.end(), [&nameRef](variables::varEntry& i) { return utilities::string::compare(i.name, nameRef); });
if (it != variables::dvars_record.end() && it->pointer) if (it != variables::dvars_record.end() && it->pointer)
{ {

30
source/proxy-dll/component/game_console.cpp
View File

@ -7,9 +7,9 @@
#include "component/dvars.hpp" #include "component/dvars.hpp"
#include "component/scheduler.hpp" #include "component/scheduler.hpp"
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
#include <utils/concurrency.hpp> #include <utilities/concurrency.hpp>
#define R_DrawTextFont reinterpret_cast<void*>(game::sharedUiInfo->assets.bigFont) #define R_DrawTextFont reinterpret_cast<void*>(game::sharedUiInfo->assets.bigFont)
#define R_WhiteMaterial reinterpret_cast<void*>(game::sharedUiInfo->assets.whiteMaterial) #define R_WhiteMaterial reinterpret_cast<void*>(game::sharedUiInfo->assets.whiteMaterial)
@ -53,7 +53,7 @@ namespace game_console
bool output_visible{}; bool output_visible{};
int display_line_offset{}; int display_line_offset{};
int total_line_count{}; int total_line_count{};
utils::concurrency::container<output_queue, std::recursive_mutex> output{}; utilities::concurrency::container<output_queue, std::recursive_mutex> output{};
}; };
ingame_console con{}; ingame_console con{};
@ -186,7 +186,7 @@ namespace game_console
for (const auto& dvar : variables::dvars_record) for (const auto& dvar : variables::dvars_record)
{ {
if (dvars::find_dvar(dvar.fnv1a) && utils::string::match(input, dvar.name) >= required_ratio) if (dvars::find_dvar(dvar.fnv1a) && utilities::string::match(input, dvar.name) >= required_ratio)
{ {
suggestions.push_back(dvar); suggestions.push_back(dvar);
} }
@ -204,7 +204,7 @@ namespace game_console
for (const auto& cmd : variables::commands_record) for (const auto& cmd : variables::commands_record)
{ {
if (utils::string::match(input, cmd.name) >= required_ratio) if (utilities::string::match(input, cmd.name) >= required_ratio)
{ {
suggestions.push_back(cmd); suggestions.push_back(cmd);
} }
@ -252,7 +252,7 @@ namespace game_console
if (matches.size() <= con.max_suggestions) if (matches.size() <= con.max_suggestions)
{ {
std::sort(matches.begin(), matches.end(), [&input](suggestion_t& lhs, suggestion_t& rhs) { std::sort(matches.begin(), matches.end(), [&input](suggestion_t& lhs, suggestion_t& rhs) {
return utils::string::match(input, lhs.name) > utils::string::match(input, rhs.name); return utilities::string::match(input, lhs.name) > utilities::string::match(input, rhs.name);
}); });
} }
@ -266,7 +266,7 @@ namespace game_console
if (matches.size() > con.max_suggestions) if (matches.size() > con.max_suggestions)
{ {
draw_hint_box(1, con_inputHintBoxColor); draw_hint_box(1, con_inputHintBoxColor);
draw_hint_text(0, utils::string::va("%i matches (too many to show here)", matches.size()), con_inputDvarMatchColor); draw_hint_text(0, utilities::string::va("%i matches (too many to show here)", matches.size()), con_inputDvarMatchColor);
} }
else if (matches.size() == 1) else if (matches.size() == 1)
{ {
@ -414,7 +414,7 @@ namespace game_console
va_end(ap); va_end(ap);
const auto formatted = std::string(va_buffer); const auto formatted = std::string(va_buffer);
const auto lines = utils::string::split(formatted, '\n'); const auto lines = utilities::string::split(formatted, '\n');
for (const auto& line : lines) for (const auto& line : lines)
{ {
@ -424,7 +424,7 @@ namespace game_console
void print(const std::string& data) void print(const std::string& data)
{ {
const auto lines = utils::string::split(data, '\n'); const auto lines = utilities::string::split(data, '\n');
for (const auto& line : lines) for (const auto& line : lines)
{ {
print_internal(line); print_internal(line);
@ -476,7 +476,7 @@ namespace game_console
if (key == 'v' - 'a' + 1) // paste if (key == 'v' - 'a' + 1) // paste
{ {
const auto clipboard = utils::string::get_clipboard_data(); const auto clipboard = utilities::string::get_clipboard_data();
if (clipboard.empty()) if (clipboard.empty())
{ {
return false; return false;
@ -646,7 +646,7 @@ namespace game_console
if (key == game::keyNum_t::K_ENTER) if (key == game::keyNum_t::K_ENTER)
{ {
//game::Cbuf_AddText(0, utils::string::va("%s \n", fixed_input.data())); //game::Cbuf_AddText(0, utilities::string::va("%s \n", fixed_input.data()));
if (history_index != -1) if (history_index != -1)
{ {
@ -661,7 +661,7 @@ namespace game_console
history.push_front(con.buffer); history.push_front(con.buffer);
print("]%s\n", con.buffer); print("]%s\n", con.buffer);
game::Cbuf_AddText(0, utils::string::va("%s \n", fixed_input.data())); game::Cbuf_AddText(0, utilities::string::va("%s \n", fixed_input.data()));
if (history.size() > 10) if (history.size() > 10)
{ {
@ -678,7 +678,7 @@ namespace game_console
return true; return true;
} }
utils::hook::detour cl_key_event_hook; utilities::hook::detour cl_key_event_hook;
void cl_key_event_stub(int localClientNum, int key, bool down, unsigned int time) void cl_key_event_stub(int localClientNum, int key, bool down, unsigned int time)
{ {
if (!game_console::console_key_event(localClientNum, key, down)) if (!game_console::console_key_event(localClientNum, key, down))
@ -689,7 +689,7 @@ namespace game_console
cl_key_event_hook.invoke<void>(localClientNum, key, down, time); cl_key_event_hook.invoke<void>(localClientNum, key, down, time);
} }
utils::hook::detour cl_char_event_hook; utilities::hook::detour cl_char_event_hook;
void cl_char_event_stub(const int localClientNum, const int key, bool isRepeated) void cl_char_event_stub(const int localClientNum, const int key, bool isRepeated)
{ {
if (!game_console::console_char_event(localClientNum, key)) if (!game_console::console_char_event(localClientNum, key))

6
source/proxy-dll/component/logger.cpp
View File

@ -3,7 +3,7 @@
#include "game_console.hpp" #include "game_console.hpp"
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/nt.hpp> #include <utilities/nt.hpp>
#define OUTPUT_DEBUG_API #define OUTPUT_DEBUG_API
#define OUTPUT_GAME_CONSOLE #define OUTPUT_GAME_CONSOLE
@ -64,11 +64,11 @@ namespace logger
void pre_start() override void pre_start() override
{ {
#ifdef REMOVE_PREVIOUS_LOG #ifdef REMOVE_PREVIOUS_LOG
utils::io::remove_file("project-bo4.log"); utilities::io::remove_file("project-bo4.log");
#endif // REMOVE_PREVIOUS_LOG #endif // REMOVE_PREVIOUS_LOG
write(LOG_TYPE_INFO, "======================================================================================================="); write(LOG_TYPE_INFO, "=======================================================================================================");
write(LOG_TYPE_INFO, " Project-BO4 Initializing ... %s[0x%llX]", utils::nt::library{}.get_name().c_str(), utils::nt::library{}.get_ptr()); write(LOG_TYPE_INFO, " Project-BO4 Initializing ... %s[0x%llX]", utilities::nt::library{}.get_name().c_str(), utilities::nt::library{}.get_ptr());
write(LOG_TYPE_INFO, "======================================================================================================="); write(LOG_TYPE_INFO, "=======================================================================================================");
} }

44
source/proxy-dll/component/platform.cpp
View File

@ -3,11 +3,11 @@
#include "definitions/game.hpp" #include "definitions/game.hpp"
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
#include <utils/identity.hpp> #include <utilities/identity.hpp>
#include <utils/json_config.hpp> #include <utilities/json_config.hpp>
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
#include <WinReg.hpp> #include <WinReg.hpp>
namespace platform namespace platform
@ -17,8 +17,8 @@ namespace platform
static uint64_t userid = 0; static uint64_t userid = 0;
if (!userid) if (!userid)
{ {
uint32_t default_xuid = utils::cryptography::xxh32::compute(utils::identity::get_sys_username()); uint32_t default_xuid = utilities::cryptography::xxh32::compute(utilities::identity::get_sys_username());
userid = utils::json_config::ReadUnsignedInteger64("identity", "xuid", default_xuid); userid = utilities::json_config::ReadUnsignedInteger64("identity", "xuid", default_xuid);
} }
return userid; return userid;
@ -29,8 +29,8 @@ namespace platform
static std::string username{}; static std::string username{};
if (username.empty()) if (username.empty())
{ {
std::string default_name = utils::identity::get_sys_username(); std::string default_name = utilities::identity::get_sys_username();
username = utils::json_config::ReadString("identity", "name", default_name); username = utilities::json_config::ReadString("identity", "name", default_name);
} }
return username.data(); return username.data();
@ -43,7 +43,7 @@ namespace platform
namespace namespace
{ {
utils::hook::detour PC_TextChat_Print_Hook; utilities::hook::detour PC_TextChat_Print_Hook;
void PC_TextChat_Print_Stub(const char* text) void PC_TextChat_Print_Stub(const char* text)
{ {
#ifdef DEBUG #ifdef DEBUG
@ -76,22 +76,22 @@ namespace platform
void post_unpack() override void post_unpack() override
{ {
utils::hook::set<uint16_t>(0x1423271D0_g, 0x01B0); // BattleNet_IsDisabled (patch to mov al,1) utilities::hook::set<uint16_t>(0x1423271D0_g, 0x01B0); // BattleNet_IsDisabled (patch to mov al,1)
utils::hook::set<uint32_t>(0x1423271E0_g, 0x90C301B0); // BattleNet_IsConnected (patch to mov al,1 retn) utilities::hook::set<uint32_t>(0x1423271E0_g, 0x90C301B0); // BattleNet_IsConnected (patch to mov al,1 retn)
utils::hook::set<uint8_t>(0x142325210_g, 0xC3); // patch#1 Annoying function crashing game; related to BattleNet (TODO : Needs Further Investigation) utilities::hook::set<uint8_t>(0x142325210_g, 0xC3); // patch#1 Annoying function crashing game; related to BattleNet (TODO : Needs Further Investigation)
utils::hook::set<uint8_t>(0x142307B40_g, 0xC3); // patch#2 Annoying function crashing game; related to BattleNet (TODO : Needs Further Investigation) utilities::hook::set<uint8_t>(0x142307B40_g, 0xC3); // patch#2 Annoying function crashing game; related to BattleNet (TODO : Needs Further Investigation)
utils::hook::set<uint32_t>(0x143D08290_g, 0x90C301B0); // patch#3 BattleNet_IsModeAvailable? (patch to mov al,1 retn) utilities::hook::set<uint32_t>(0x143D08290_g, 0x90C301B0); // patch#3 BattleNet_IsModeAvailable? (patch to mov al,1 retn)
utils::hook::nop(0x1437DA454_g, 13); // begin cross-auth even without platform being initialized [LiveConnect_BeginCrossAuthPlatform] utilities::hook::nop(0x1437DA454_g, 13); // begin cross-auth even without platform being initialized [LiveConnect_BeginCrossAuthPlatform]
utils::hook::set(0x1444D2D60_g, 0xC301B0); // Auth3 Response RSA signature check [bdAuth::validateResponseSignature] utilities::hook::set(0x1444D2D60_g, 0xC301B0); // Auth3 Response RSA signature check [bdAuth::validateResponseSignature]
utils::hook::set(0x1444E34C0_g, 0xC301B0); // Auth3 Response platform extended data check [bdAuthPC::processPlatformData] utilities::hook::set(0x1444E34C0_g, 0xC301B0); // Auth3 Response platform extended data check [bdAuthPC::processPlatformData]
utils::hook::nop(0x1438994E9_g, 22); // get live name even without platform being initialized [Live_UserSignedIn] utilities::hook::nop(0x1438994E9_g, 22); // get live name even without platform being initialized [Live_UserSignedIn]
utils::hook::nop(0x1438C3476_g, 22); // get live xuid even without platform being initialized [LiveUser_UserGetXuid] utilities::hook::nop(0x1438C3476_g, 22); // get live xuid even without platform being initialized [LiveUser_UserGetXuid]
utils::hook::jump(0x142325C70_g, bnet_get_username); // detour battlenet username utilities::hook::jump(0x142325C70_g, bnet_get_username); // detour battlenet username
utils::hook::jump(0x142325CA0_g, bnet_get_userid); // detour battlenet userid utilities::hook::jump(0x142325CA0_g, bnet_get_userid); // detour battlenet userid
//PC_TextChat_Print_Hook.create(0x1422D4A20_g, PC_TextChat_Print_Stub); // Disable useless system messages passed into chat box //PC_TextChat_Print_Hook.create(0x1422D4A20_g, PC_TextChat_Print_Stub); // Disable useless system messages passed into chat box

18
source/proxy-dll/component/scheduler.cpp
View File

@ -3,9 +3,9 @@
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <cassert> #include <cassert>
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/concurrency.hpp> #include <utilities/concurrency.hpp>
#include <utils/thread.hpp> #include <utilities/thread.hpp>
namespace scheduler namespace scheduler
{ {
@ -64,8 +64,8 @@ namespace scheduler
} }
private: private:
utils::concurrency::container<task_list> new_callbacks_; utilities::concurrency::container<task_list> new_callbacks_;
utils::concurrency::container<task_list, std::recursive_mutex> callbacks_; utilities::concurrency::container<task_list, std::recursive_mutex> callbacks_;
void merge_callbacks() void merge_callbacks()
{ {
@ -85,9 +85,9 @@ namespace scheduler
std::thread thread; std::thread thread;
task_pipeline pipelines[pipeline::count]; task_pipeline pipelines[pipeline::count];
utils::hook::detour r_end_frame_hook; utilities::hook::detour r_end_frame_hook;
utils::hook::detour g_run_frame_hook; utilities::hook::detour g_run_frame_hook;
utils::hook::detour main_frame_hook; utilities::hook::detour main_frame_hook;
void execute(const pipeline type) void execute(const pipeline type)
{ {
@ -152,7 +152,7 @@ namespace scheduler
public: public:
void pre_start() override void pre_start() override
{ {
thread = utils::thread::create_named_thread("Async Scheduler", []() thread = utilities::thread::create_named_thread("Async Scheduler", []()
{ {
while (!kill) while (!kill)
{ {

22
source/proxy-dll/component/splash.cpp
View File

@ -4,30 +4,30 @@
#include "resource.hpp" #include "resource.hpp"
#include <utils/nt.hpp> #include <utilities/nt.hpp>
#include <utils/image.hpp> #include <utilities/image.hpp>
namespace splash namespace splash
{ {
namespace namespace
{ {
HWND window{}; HWND window{};
utils::image::object image{}; utilities::image::object image{};
std::thread window_thread{}; std::thread window_thread{};
utils::image::object load_splash_image() utilities::image::object load_splash_image()
{ {
//const auto self = utils::nt::library::get_by_address(load_splash_image); //const auto self = utilities::nt::library::get_by_address(load_splash_image);
//return LoadImageA(self, MAKEINTRESOURCE(IMAGE_SPLASH), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); //return LoadImageA(self, MAKEINTRESOURCE(IMAGE_SPLASH), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
const auto res = utils::nt::load_resource(IMAGE_SPLASH); const auto res = utilities::nt::load_resource(IMAGE_SPLASH);
const auto img = utils::image::load_image(res); const auto img = utilities::image::load_image(res);
return utils::image::create_bitmap(img); return utilities::image::create_bitmap(img);
} }
void enable_dpi_awareness() void enable_dpi_awareness()
{ {
const utils::nt::library user32{ "user32.dll" }; const utilities::nt::library user32{ "user32.dll" };
const auto set_dpi = user32 const auto set_dpi = user32
? user32.get_proc<BOOL(WINAPI*)(DPI_AWARENESS_CONTEXT)>( ? user32.get_proc<BOOL(WINAPI*)(DPI_AWARENESS_CONTEXT)>(
"SetProcessDpiAwarenessContext") "SetProcessDpiAwarenessContext")
@ -63,7 +63,7 @@ namespace splash
{ {
WNDCLASSA wnd_class; WNDCLASSA wnd_class;
const auto self = utils::nt::library::get_by_address(load_splash_image); const auto self = utilities::nt::library::get_by_address(load_splash_image);
wnd_class.style = CS_DROPSHADOW; wnd_class.style = CS_DROPSHADOW;
wnd_class.cbClsExtra = 0; wnd_class.cbClsExtra = 0;
@ -161,7 +161,7 @@ namespace splash
} }
window = nullptr; window = nullptr;
UnregisterClassA("Black Ops 4 Splash Screen", utils::nt::library{}); UnregisterClassA("Black Ops 4 Splash Screen", utilities::nt::library{});
} }
} }

4
source/proxy-dll/component/unlockall.cpp
View File

@ -1,7 +1,7 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/hook.hpp> #include <utilities/hook.hpp>
namespace unlockall namespace unlockall
{ {
@ -103,7 +103,7 @@ namespace unlockall
public: public:
void post_unpack() override void post_unpack() override
{ {
utils::hook::jump(0x1437F6ED0_g, liveinventory_getitemquantity); utilities::hook::jump(0x1437F6ED0_g, liveinventory_getitemquantity);
} }
}; };
} }

8
source/proxy-dll/definitions/discovery.cpp
View File

@ -2,8 +2,8 @@
#include "discovery.hpp" #include "discovery.hpp"
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/signature.hpp> #include <utilities/signature.hpp>
std::unordered_map<std::string, size_t> symbols_list; std::unordered_map<std::string, size_t> symbols_list;
@ -98,7 +98,7 @@ namespace discovery
continue; continue;
} }
utils::hook::signature::signature_result scan = utils::hook::signature(std::string(i.sig, strlen(i.sig))).process(); utilities::hook::signature::signature_result scan = utilities::hook::signature(std::string(i.sig, strlen(i.sig))).process();
if (scan.size() == 0 || scan.size() > 1) if (scan.size() == 0 || scan.size() > 1)
{ {
@ -126,7 +126,7 @@ namespace discovery
if (symbols_list.find("com_get_build_version") != symbols_list.end()) if (symbols_list.find("com_get_build_version") != symbols_list.end())
{ {
const char* build_version = utils::hook::invoke<const char*>(symbols_list["com_get_build_version"]); const char* build_version = utilities::hook::invoke<const char*>(symbols_list["com_get_build_version"]);
logger::write(logger::LOG_TYPE_DEBUG, "Address-List Discovery Results for BlackOps4 %s", build_version); logger::write(logger::LOG_TYPE_DEBUG, "Address-List Discovery Results for BlackOps4 %s", build_version);
} }

20
source/proxy-dll/demonware/byte_buffer.cpp
View File

@ -169,24 +169,28 @@ namespace demonware
return type == expected; return type == expected;
} }
bool byte_buffer::read_array_header(const unsigned char expected, unsigned int* element_count, bool byte_buffer::read_array_header(const unsigned char expected
unsigned int* element_size) , unsigned int* element_count, unsigned int* element_size)
{ {
if (element_count) *element_count = 0; if (element_count) *element_count = 0;
if (element_size) *element_size = 0; if (element_size) *element_size = 0;
const auto using_types = this->is_using_data_types();
this->set_use_data_types(true);
if (!this->read_data_type(expected + 100)) return false; if (!this->read_data_type(expected + 100)) return false;
uint32_t array_size, el_count; uint32_t array_size, num_elements;
if (!this->read_uint32(&array_size)) return false; if (!this->read_uint32(&array_size)) return false;
this->set_use_data_types(false); this->set_use_data_types(false);
this->read_uint32(&el_count); if (!this->read_uint32(&num_elements)) return false;
this->set_use_data_types(true); this->set_use_data_types(true);
if (element_count) *element_count = el_count; if (element_count) *element_count = num_elements;
if (element_size) *element_size = array_size / el_count; if (element_size) *element_size = array_size / num_elements;
this->set_use_data_types(using_types);
return true; return true;
} }
@ -293,8 +297,8 @@ namespace demonware
return this->write(length, data); return this->write(length, data);
} }
bool byte_buffer::write_array_header(const unsigned char type, const unsigned int element_count, bool byte_buffer::write_array_header(const unsigned char type,
const unsigned int element_size) const unsigned int element_count, const unsigned int element_size)
{ {
const auto using_types = this->is_using_data_types(); const auto using_types = this->is_using_data_types();
this->set_use_data_types(false); this->set_use_data_types(false);

94
source/proxy-dll/demonware/byte_buffer.hpp
View File

@ -30,8 +30,59 @@ namespace demonware
bool read_struct(std::string* output); bool read_struct(std::string* output);
bool read_data_type(char expected); bool read_data_type(char expected);
bool read_array_header(unsigned char expected, unsigned int* element_count, bool read_array_header(const unsigned char expected
unsigned int* element_size = nullptr); , unsigned int* element_count, unsigned int* element_size);
template <typename T>
bool read_array(const unsigned char expected, std::vector<T>* vec)
{
const auto using_types = this->is_using_data_types();
this->set_use_data_types(false);
uint32_t ItemCount, itemSize;
if (!this->read_array_header(expected, &ItemCount, &itemSize)) return false;
if (itemSize != sizeof(T)) return false;
for (size_t i = 0; i < ItemCount; i++)
{
T item{};
if (!this->read(sizeof(T), &item)) return false;
vec->push_back(item);
}
this->set_use_data_types(using_types);
return true;
}
template <typename T>
bool read_array(const unsigned char expected, std::map<T, T>* map)
{
const auto using_types = this->is_using_data_types();
this->set_use_data_types(false);
uint32_t ItemCount, itemSize;
if (!this->read_array_header(expected, &ItemCount, &itemSize)) return false;
if (itemSize != sizeof(T)) return false;
for (size_t i = 0; i < ItemCount / 2; i++)
{
T key{}, value{};
if (!this->read(sizeof(T), &key)
|| !this->read(sizeof(T), &value)
) return false;
map->insert({ key, value });
}
this->set_use_data_types(using_types);
return true;
}
bool write_bool(bool data); bool write_bool(bool data);
bool write_byte(char data); bool write_byte(char data);
@ -51,7 +102,44 @@ namespace demonware
bool write_struct(const char* data, int length); bool write_struct(const char* data, int length);
bool write_struct(const std::string& data); bool write_struct(const std::string& data);
bool write_array_header(unsigned char type, unsigned int element_count, unsigned int element_size); bool write_array_header(const unsigned char type,
const unsigned int element_count, const unsigned int element_size);
template <typename T>
bool write_array(const unsigned char type, const std::vector<T>& vec)
{
const auto using_types = this->is_using_data_types();
this->set_use_data_types(false);
auto result = write_array_header(type, vec.size(), sizeof(T));
for (size_t i = 0; i < vec.size(); i++)
{
result &= this->write(sizeof(T), &vec[i]);
}
this->set_use_data_types(using_types);
return result;
}
template <typename T>
bool write_array(const unsigned char type, const std::map<T, T>& map)
{
const auto using_types = this->is_using_data_types();
this->set_use_data_types(false);
auto result = write_array_header(type, map.size() * 2, sizeof(T));
for (const auto& item : map)
{
result &= this->write(sizeof(T), &item.first);
result &= this->write(sizeof(T), &item.second);
}
this->set_use_data_types(using_types);
return result;
}
bool read(int bytes, void* output); bool read(int bytes, void* output);
bool write(int bytes, const void* data); bool write(int bytes, const void* data);

224
source/proxy-dll/demonware/data_types.hpp
View File

@ -18,10 +18,58 @@ namespace demonware
} }
}; };
class bdStringResult final : public bdTaskResult
{
public:
std::string content = "";
void serialize(byte_buffer* buffer) override
{
buffer->write_string(this->content);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_string(&this->content);
}
};
class bdUInt64Result final : public bdTaskResult
{
public:
uint64_t value = 0;
void serialize(byte_buffer* buffer) override
{
buffer->write_uint64(this->value);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_uint64(&this->value);
}
};
class bdBoolResult final : public bdTaskResult
{
public:
bool value = false;
void serialize(byte_buffer* buffer) override
{
buffer->write_bool(this->value);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_bool(&this->value);
}
};
class bdTimeStamp final : public bdTaskResult class bdTimeStamp final : public bdTaskResult
{ {
public: public:
uint32_t unix_time; uint32_t unix_time = 0;
void serialize(byte_buffer* buffer) override void serialize(byte_buffer* buffer) override
{ {
@ -37,14 +85,14 @@ namespace demonware
class bdDMLInfo : public bdTaskResult class bdDMLInfo : public bdTaskResult
{ {
public: public:
std::string country_code; // Char [3] std::string country_code = ""; // Char [3]
std::string country; // Char [65] std::string country = ""; // Char [65]
std::string region; // Char [65] std::string region = ""; // Char [65]
std::string city; // Char [129] std::string city = ""; // Char [129]
float latitude; float latitude = 0.0f;
float longitude; float longitude = 0;
uint32_t asn; // Autonomous System Number. uint32_t asn = 0; // Autonomous System Number.
std::string timezone; std::string timezone = "";
void serialize(byte_buffer* buffer) override void serialize(byte_buffer* buffer) override
{ {
@ -74,11 +122,11 @@ namespace demonware
class bdDMLHierarchicalInfo final : public bdDMLInfo class bdDMLHierarchicalInfo final : public bdDMLInfo
{ {
public: public:
uint32_t m_tier0; uint32_t m_tier0 = 0;
uint32_t m_tier1; uint32_t m_tier1 = 0;
uint32_t m_tier2; uint32_t m_tier2 = 0;
uint32_t m_tier3; uint32_t m_tier3 = 0;
uint32_t m_confidence; uint32_t m_confidence = 0;
void serialize(byte_buffer* buffer) override void serialize(byte_buffer* buffer) override
{ {
@ -103,74 +151,12 @@ namespace demonware
} }
}; };
class bdStructedDataBuffer final : public bdTaskResult
{
public:
std::string structed_data_protobuffer;
void serialize(byte_buffer* buffer) override
{
buffer->write_struct(this->structed_data_protobuffer);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_struct(&this->structed_data_protobuffer);
}
};
class bdMarketplaceInventory final : public bdTaskResult
{
public:
uint64_t m_userID;
std::string m_accountType;
uint32_t m_itemId;
uint32_t m_itemQuantity;
uint32_t m_itemXp;
std::string m_itemData;
uint32_t m_expireDateTime;
int64_t m_expiryDuration;
uint16_t m_collisionField;
uint32_t m_modDateTime;
uint32_t m_customSourceType;
void serialize(byte_buffer* buffer) override
{
buffer->write_uint64(this->m_userID);
buffer->write_string(this->m_accountType);
buffer->write_uint32(this->m_itemId);
buffer->write_uint32(this->m_itemQuantity);
buffer->write_uint32(this->m_itemXp);
buffer->write_blob(this->m_itemData);
buffer->write_uint32(this->m_expireDateTime);
buffer->write_int64(this->m_expiryDuration);
buffer->write_uint16(this->m_collisionField);
buffer->write_uint32(this->m_modDateTime);
buffer->write_uint32(this->m_customSourceType);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_uint64(&this->m_userID);
buffer->read_string(&this->m_accountType);
buffer->read_uint32(&this->m_itemId);
buffer->read_uint32(&this->m_itemQuantity);
buffer->read_uint32(&this->m_itemXp);
buffer->read_blob(&this->m_itemData);
buffer->read_uint32(&this->m_expireDateTime);
buffer->read_int64(&this->m_expiryDuration);
buffer->read_uint16(&this->m_collisionField);
buffer->read_uint32(&this->m_modDateTime);
buffer->read_uint32(&this->m_customSourceType);
}
};
class bdPublicProfileInfo final : public bdTaskResult class bdPublicProfileInfo final : public bdTaskResult
{ {
public: public:
uint64_t m_entityID; uint64_t m_entityID = 0;
int32_t m_VERSION; int32_t m_VERSION = 0;
std::string m_ddl; std::string m_ddl = "";
void serialize(byte_buffer* buffer) override void serialize(byte_buffer* buffer) override
{ {
@ -186,4 +172,84 @@ namespace demonware
buffer->read_blob(&this->m_ddl); buffer->read_blob(&this->m_ddl);
} }
}; };
class bdFileMetaData final : public bdTaskResult
{
public:
uint64_t m_fileID = 0;
uint32_t m_createTime = 0;
uint32_t m_modifedTime = 0;
uint32_t m_fileSize = 0;
uint64_t m_ownerID = 0;
std::string m_ownerName = "";
uint16_t m_fileSlot = 0;
std::string m_fileName = "";
std::string m_url = "";
uint16_t m_category = 0;
std::string m_metaData = "";
uint32_t m_summaryFileSize = 0;
std::map<uint64_t, uint64_t> m_tags;
uint32_t m_numCopiesMade = 0;
uint64_t m_originID = 0;
void serialize(byte_buffer* buffer) override
{
buffer->write_uint64(this->m_fileID);
buffer->write_uint32(this->m_createTime);
buffer->write_uint32(this->m_modifedTime);
buffer->write_uint32(this->m_fileSize);
buffer->write_uint64(this->m_ownerID);
buffer->write_string(this->m_ownerName);
buffer->write_uint16(this->m_fileSlot);
buffer->write_string(this->m_fileName);
buffer->write_string(this->m_url);
buffer->write_uint16(this->m_category);
buffer->write_blob(this->m_metaData);
buffer->write_uint32(this->m_summaryFileSize);
buffer->write_array(10, m_tags);
buffer->write_uint32(this->m_numCopiesMade);
buffer->write_uint64(this->m_originID);
}
};
class bdURL final : public bdTaskResult
{
public:
std::string m_url = "";
uint16_t m_serverType = 0;
std::string m_serverIndex = "";
uint64_t m_fileID = 0;
void serialize(byte_buffer* buffer) override
{
buffer->write_string(this->m_url);
buffer->write_uint16(this->m_serverType);
buffer->write_string(this->m_serverIndex);
buffer->write_uint64(this->m_fileID);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_string(&this->m_url);
buffer->read_uint16(&this->m_serverType);
buffer->read_string(&this->m_serverIndex);
buffer->read_uint64(&this->m_fileID);
}
};
class bdStructedDataBuffer final : public bdTaskResult
{
public:
std::string structed_data_protobuffer = "";
void serialize(byte_buffer* buffer) override
{
buffer->write_struct(this->structed_data_protobuffer);
}
void deserialize(byte_buffer* buffer) override
{
buffer->read_struct(&this->structed_data_protobuffer);
}
};
} }

26
source/proxy-dll/demonware/keys.cpp
View File

@ -1,12 +1,12 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "keys.hpp" #include "keys.hpp"
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
#include <utils/io.hpp> #include <utilities/io.hpp>
#include "resource.hpp" #include "resource.hpp"
#include <utils/nt.hpp> #include <utilities/nt.hpp>
namespace demonware namespace demonware
@ -41,7 +41,7 @@ namespace demonware
pos++; pos++;
// calculate hmac // calculate hmac
result = utils::cryptography::hmac_sha1::compute(std::string(buffer, pos), std::string(dataxx, data_size)); result = utilities::cryptography::hmac_sha1::compute(std::string(buffer, pos), std::string(dataxx, data_size));
// save output // save output
std::memcpy(dest, result.data(), std::min(20u, (dest_size - out_offset))); std::memcpy(dest, result.data(), std::min(20u, (dest_size - out_offset)));
@ -69,7 +69,7 @@ namespace demonware
pos++; pos++;
// calculate hmac // calculate hmac
result = utils::cryptography::hmac_sha1::compute(std::string(buffer, pos), std::string(dataxx, data_size)); result = utilities::cryptography::hmac_sha1::compute(std::string(buffer, pos), std::string(dataxx, data_size));
// save output // save output
std::memcpy(dest + out_offset, result.data(), std::min(20u, (dest_size - out_offset))); std::memcpy(dest + out_offset, result.data(), std::min(20u, (dest_size - out_offset)));
@ -79,14 +79,14 @@ namespace demonware
void derive_keys_iw8() void derive_keys_iw8()
{ {
std::string BD_AUTH_TRAFFIC_SIGNING_KEY = utils::nt::load_resource(DW_AUTH_TRAFFIC_SIGNING_KEY); std::string BD_AUTH_TRAFFIC_SIGNING_KEY = utilities::nt::load_resource(DW_AUTH_TRAFFIC_SIGNING_KEY);
const auto packet_hash = utils::cryptography::sha1::compute(packet_buffer); const auto packet_hash = utilities::cryptography::sha1::compute(packet_buffer);
char out_1[24]; char out_1[24];
calculate_hmacs(data.m_session_key, 24, BD_AUTH_TRAFFIC_SIGNING_KEY.data(), 294, out_1, 24); calculate_hmacs(data.m_session_key, 24, BD_AUTH_TRAFFIC_SIGNING_KEY.data(), 294, out_1, 24);
auto data_3 = utils::cryptography::hmac_sha1::compute(std::string(out_1, 24), packet_hash); auto data_3 = utilities::cryptography::hmac_sha1::compute(std::string(out_1, 24), packet_hash);
char out_2[16]; char out_2[16];
calculate_hmacs(data_3.data(), 20, "CLIENTCHAL", 10, out_2, 16); calculate_hmacs(data_3.data(), 20, "CLIENTCHAL", 10, out_2, 16);
@ -101,10 +101,10 @@ namespace demonware
std::memcpy(data.m_enc_key, &out_3[56], 16); std::memcpy(data.m_enc_key, &out_3[56], 16);
#ifndef NDEBUG #ifndef NDEBUG
logger::write(logger::LOG_TYPE_DEBUG, "[DW] Response id: %s", utils::string::dump_hex(std::string(&out_2[8], 8)).data()); logger::write(logger::LOG_TYPE_DEBUG, "[DW] Response id: %s", utilities::string::dump_hex(std::string(&out_2[8], 8)).data());
logger::write(logger::LOG_TYPE_DEBUG, "[DW] Hash verify: %s", utils::string::dump_hex(std::string(&out_3[20], 20)).data()); logger::write(logger::LOG_TYPE_DEBUG, "[DW] Hash verify: %s", utilities::string::dump_hex(std::string(&out_3[20], 20)).data());
logger::write(logger::LOG_TYPE_DEBUG, "[DW] AES dec key: %s", utils::string::dump_hex(std::string(&out_3[40], 16)).data()); logger::write(logger::LOG_TYPE_DEBUG, "[DW] AES dec key: %s", utilities::string::dump_hex(std::string(&out_3[40], 16)).data());
logger::write(logger::LOG_TYPE_DEBUG, "[DW] AES enc key: %s", utils::string::dump_hex(std::string(&out_3[56], 16)).data()); logger::write(logger::LOG_TYPE_DEBUG, "[DW] AES enc key: %s", utilities::string::dump_hex(std::string(&out_3[56], 16)).data());
logger::write(logger::LOG_TYPE_DEBUG, "[DW] Bravo 6, going dark."); logger::write(logger::LOG_TYPE_DEBUG, "[DW] Bravo 6, going dark.");
#endif #endif
} }

58
source/proxy-dll/demonware/objects.cpp
View File

@ -4,10 +4,10 @@
#include "protobuf_helper.hpp" #include "protobuf_helper.hpp"
#include "resource.hpp" #include "resource.hpp"
#include <utils/nt.hpp> #include <utilities/nt.hpp>
#include <utils/io.hpp> #include <utilities/io.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
#include <component/platform.hpp> #include <component/platform.hpp>
#define PUBLISHER_OBJECTS_ENUMERATE_LPC_DIR #define PUBLISHER_OBJECTS_ENUMERATE_LPC_DIR
@ -30,11 +30,11 @@ namespace demonware
std::string get_publisher_file_checksum(std::string file) std::string get_publisher_file_checksum(std::string file)
{ {
std::string file_data; std::string file_data;
if (!utils::io::read_file(file, &file_data)) return ""; if (!utilities::io::read_file(file, &file_data)) return "";
std::string checksum_md5 = utils::cryptography::md5::compute(file_data); std::string checksum_md5 = utilities::cryptography::md5::compute(file_data);
return utils::cryptography::base64::encode(checksum_md5); return utilities::cryptography::base64::encode(checksum_md5);
} }
std::vector<objectMetadata> get_publisher_objects_list(const std::string& category) std::vector<objectMetadata> get_publisher_objects_list(const std::string& category)
@ -42,24 +42,24 @@ namespace demonware
std::vector<objectMetadata> result; std::vector<objectMetadata> result;
#ifdef PUBLISHER_OBJECTS_ENUMERATE_LPC_DIR #ifdef PUBLISHER_OBJECTS_ENUMERATE_LPC_DIR
std::vector<std::string> files = utils::io::list_files("LPC"); std::vector<std::string> files = utilities::io::list_files("LPC");
for (std::string file : files) for (std::string file : files)
{ {
if (!utils::string::ends_with(file, ".ff")) continue; if (!utilities::string::ends_with(file, ".ff")) continue;
int64_t timestamp = static_cast<int64_t>(time(nullptr)); int64_t timestamp = static_cast<int64_t>(time(nullptr));
result.push_back({ "treyarch", utils::io::file_name(file), get_publisher_file_checksum(file), utils::io::file_size(file), timestamp, timestamp, "" }); result.push_back({ "treyarch", utilities::io::file_name(file), get_publisher_file_checksum(file), utilities::io::file_size(file), timestamp, timestamp, "" });
} }
#else // PUBLISHER_OBJECTS_ENUMERATE_CSV_LIST #else // PUBLISHER_OBJECTS_ENUMERATE_CSV_LIST
const auto objects_list_csv = utils::nt::load_resource(DW_PUBLISHER_OBJECTS_LIST); const auto objects_list_csv = utilities::nt::load_resource(DW_PUBLISHER_OBJECTS_LIST);
std::vector<std::string> items = utils::string::split(objects_list_csv, "\r\n"); // WTF!? std::vector<std::string> items = utilities::string::split(objects_list_csv, "\r\n"); // WTF!?
for (std::string item : items) for (std::string item : items)
{ {
std::string checksum = utils::cryptography::base64::encode(HexStringToBinaryString(utils::string::split(item, ',')[2])); std::string checksum = utilities::cryptography::base64::encode(HexStringToBinaryString(utilities::string::split(item, ',')[2]));
std::string name = utils::string::split(item, ',')[0]; std::string name = utilities::string::split(item, ',')[0];
uint64_t length = std::stoull(utils::string::split(item, ',')[1]); uint64_t length = std::stoull(utilities::string::split(item, ',')[1]);
int64_t timestamp = static_cast<int64_t>(time(nullptr)); int64_t timestamp = static_cast<int64_t>(time(nullptr));
result.push_back({ "treyarch", name, checksum, length, timestamp, timestamp, "" }); result.push_back({ "treyarch", name, checksum, length, timestamp, timestamp, "" });
@ -159,17 +159,17 @@ namespace demonware
std::string get_user_file_checksum(std::string file_path) std::string get_user_file_checksum(std::string file_path)
{ {
std::string file_data; std::string file_data;
if (!utils::io::read_file(file_path, &file_data)) return ""; if (!utilities::io::read_file(file_path, &file_data)) return "";
return std::to_string(utils::cryptography::xxh32::compute(file_data)); return std::to_string(utilities::cryptography::xxh32::compute(file_data));
} }
std::string get_user_file_content(std::string file_path) std::string get_user_file_content(std::string file_path)
{ {
std::string file_data; std::string file_data;
if (!utils::io::read_file(file_path, &file_data)) return ""; if (!utilities::io::read_file(file_path, &file_data)) return "";
return utils::cryptography::base64::encode(file_data); return utilities::cryptography::base64::encode(file_data);
} }
std::string deliver_user_objects_vectorized_json(std::vector<objectMetadata> requested_items) std::string deliver_user_objects_vectorized_json(std::vector<objectMetadata> requested_items)
@ -294,7 +294,7 @@ namespace demonware
{ {
std::string file_path = get_user_file_path(file.name); std::string file_path = get_user_file_path(file.name);
int64_t timestamp = static_cast<int64_t>(time(nullptr)); int64_t timestamp = static_cast<int64_t>(time(nullptr));
files_metadata_list.push_back({ file.owner, file.name, get_user_file_checksum(file_path), utils::io::file_size(file_path), timestamp, timestamp, get_user_file_content(file_path) }); files_metadata_list.push_back({ file.owner, file.name, get_user_file_checksum(file_path), utilities::io::file_size(file_path), timestamp, timestamp, get_user_file_content(file_path) });
} }
return deliver_user_objects_vectorized_json(files_metadata_list); return deliver_user_objects_vectorized_json(files_metadata_list);
@ -318,9 +318,9 @@ namespace demonware
std::string userdata_directory = platform::get_userdata_directory(); std::string userdata_directory = platform::get_userdata_directory();
if (utils::io::directory_exists(userdata_directory)) if (utilities::io::directory_exists(userdata_directory))
{ {
std::vector<std::string> user_objects = utils::io::list_files(userdata_directory); std::vector<std::string> user_objects = utilities::io::list_files(userdata_directory);
for (std::string object : user_objects) for (std::string object : user_objects)
{ {
@ -336,7 +336,7 @@ namespace demonware
json_writer.Uint(0); json_writer.Uint(0);
json_writer.Key("name"); json_writer.Key("name");
json_writer.String(utils::io::file_name(object)); json_writer.String(utilities::io::file_name(object));
json_writer.Key("checksum"); json_writer.Key("checksum");
json_writer.String(get_user_file_checksum(object)); json_writer.String(get_user_file_checksum(object));
@ -354,7 +354,7 @@ namespace demonware
json_writer.Null(); json_writer.Null();
json_writer.Key("contentLength"); json_writer.Key("contentLength");
json_writer.Uint64(utils::io::file_size(object)); json_writer.Uint64(utilities::io::file_size(object));
json_writer.Key("context"); json_writer.Key("context");
json_writer.String("t8-bnet"); json_writer.String("t8-bnet");
@ -404,9 +404,9 @@ namespace demonware
std::string userdata_directory = platform::get_userdata_directory(); std::string userdata_directory = platform::get_userdata_directory();
int files_count = 0; int files_count = 0;
if (utils::io::directory_exists(userdata_directory)) if (utilities::io::directory_exists(userdata_directory))
{ {
files_count = static_cast<int32_t>(utils::io::list_files(userdata_directory).size()); files_count = static_cast<int32_t>(utilities::io::list_files(userdata_directory).size());
} }
@ -467,7 +467,7 @@ namespace demonware
json_writer.Null(); json_writer.Null();
json_writer.Key("contentLength"); json_writer.Key("contentLength");
json_writer.Uint64(utils::io::file_size(file_path)); json_writer.Uint64(utilities::io::file_size(file_path));
json_writer.Key("context"); json_writer.Key("context");
json_writer.String("t8-bnet"); json_writer.String("t8-bnet");
@ -599,7 +599,7 @@ namespace demonware
{ {
std::string file_path = get_user_file_path(file); std::string file_path = get_user_file_path(file);
int64_t timestamp = static_cast<int64_t>(time(nullptr)); int64_t timestamp = static_cast<int64_t>(time(nullptr));
files_metadata_list.push_back({ std::format("bnet-{}", platform::bnet_get_userid()), file, get_user_file_checksum(file_path), utils::io::file_size(file_path), timestamp, timestamp, get_user_file_content(file_path) }); files_metadata_list.push_back({ std::format("bnet-{}", platform::bnet_get_userid()), file, get_user_file_checksum(file_path), utilities::io::file_size(file_path), timestamp, timestamp, get_user_file_content(file_path) });
} }
return construct_vectorized_upload_list_json(files_metadata_list); return construct_vectorized_upload_list_json(files_metadata_list);
@ -609,7 +609,7 @@ namespace demonware
{ {
bdProtobufHelper header_1st; bdProtobufHelper header_1st;
header_1st.writeString(1, "Content-Length", 16); header_1st.writeString(1, "Content-Length", 16);
header_1st.writeString(2, utils::string::va("%u", payload.length()), 8); header_1st.writeString(2, utilities::string::va("%u", payload.length()), 8);
bdProtobufHelper header_2nd; bdProtobufHelper header_2nd;
header_2nd.writeString(1, "Authorization", 16); header_2nd.writeString(1, "Authorization", 16);

6
source/proxy-dll/demonware/reply.cpp
View File

@ -3,7 +3,7 @@
#include "reply.hpp" #include "reply.hpp"
#include "servers/service_server.hpp" #include "servers/service_server.hpp"
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
namespace demonware namespace demonware
{ {
@ -41,7 +41,7 @@ namespace demonware
std::string seed("\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED", 16); std::string seed("\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED", 16);
// encrypt // encrypt
const auto enc_data = utils::cryptography::aes::encrypt(aligned_data, seed, demonware::get_encrypt_key()); const auto enc_data = utilities::cryptography::aes::encrypt(aligned_data, seed, demonware::get_encrypt_key());
// header : encrypted service data : hash // header : encrypted service data : hash
static auto msg_count = 0; static auto msg_count = 0;
@ -58,7 +58,7 @@ namespace demonware
response.write(enc_data); response.write(enc_data);
// hash entire packet and append end // hash entire packet and append end
auto hash_data = utils::cryptography::hmac_sha1::compute(response.get_buffer(), demonware::get_hmac_key()); auto hash_data = utilities::cryptography::hmac_sha1::compute(response.get_buffer(), demonware::get_hmac_key());
hash_data.resize(8); hash_data.resize(8);
response.write(8, hash_data.data()); response.write(8, hash_data.data());

4
source/proxy-dll/demonware/server_registry.hpp
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "servers/base_server.hpp" #include "servers/base_server.hpp"
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
namespace demonware namespace demonware
{ {
@ -31,7 +31,7 @@ namespace demonware
T* find(const std::string& name) T* find(const std::string& name)
{ {
const auto address = utils::cryptography::jenkins_one_at_a_time::compute(name); const auto address = utilities::cryptography::jenkins_one_at_a_time::compute(name);
return find(address); return find(address);
} }

16
source/proxy-dll/demonware/servers/auth3_server.cpp
View File

@ -3,8 +3,8 @@
#include "auth3_server.hpp" #include "auth3_server.hpp"
#include "../keys.hpp" #include "../keys.hpp"
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
namespace demonware namespace demonware
{ {
@ -84,7 +84,7 @@ namespace demonware
{ {
auto& token_field = extra_data["account_token"]; auto& token_field = extra_data["account_token"];
std::string token_b64(token_field.GetString(), token_field.GetStringLength()); std::string token_b64(token_field.GetString(), token_field.GetStringLength());
account_token = utils::cryptography::base64::decode(token_b64); account_token = utilities::cryptography::base64::decode(token_b64);
} }
} }
@ -104,13 +104,13 @@ namespace demonware
strncpy_s(ticket.m_username, sizeof(ticket.m_username), session_token.data(), session_token.length()); strncpy_s(ticket.m_username, sizeof(ticket.m_username), session_token.data(), session_token.length());
std::memcpy(ticket.m_sessionKey, session_key.data(), 24); std::memcpy(ticket.m_sessionKey, session_key.data(), 24);
const auto client_ticket_b64 = utils::cryptography::base64::encode(reinterpret_cast<const unsigned char*>(&ticket), sizeof(ticket)); const auto client_ticket_b64 = utilities::cryptography::base64::encode(reinterpret_cast<const unsigned char*>(&ticket), sizeof(ticket));
// server_ticket // server_ticket
uint8_t server_ticket[128]; uint8_t server_ticket[128];
std::memset(&server_ticket, 0, sizeof server_ticket); std::memset(&server_ticket, 0, sizeof server_ticket);
std::memcpy(server_ticket, session_key.data(), 24); std::memcpy(server_ticket, session_key.data(), 24);
const auto server_ticket_b64 = utils::cryptography::base64::encode(server_ticket, 128); const auto server_ticket_b64 = utilities::cryptography::base64::encode(server_ticket, 128);
demonware::set_session_key(session_key); demonware::set_session_key(session_key);
@ -128,7 +128,7 @@ namespace demonware
extra.AddMember("username", username, extra.GetAllocator()); extra.AddMember("username", username, extra.GetAllocator());
extra.AddMember("time_to_live", 9999, extra.GetAllocator()); extra.AddMember("time_to_live", 9999, extra.GetAllocator());
const auto lul = utils::cryptography::base64::encode("lul"); const auto lul = utilities::cryptography::base64::encode("lul");
extra.AddMember("extended_data", lul, extra.GetAllocator()); extra.AddMember("extended_data", lul, extra.GetAllocator());
rapidjson::StringBuffer extra_buffer{}; rapidjson::StringBuffer extra_buffer{};
@ -170,8 +170,8 @@ namespace demonware
result.append("HTTP/1.1 200 OK\r\n"); result.append("HTTP/1.1 200 OK\r\n");
result.append("Server: TornadoServer/4.5.3\r\n"); result.append("Server: TornadoServer/4.5.3\r\n");
result.append("Content-Type: application/json\r\n"); result.append("Content-Type: application/json\r\n");
result.append(utils::string::va("Date: %s GMT\r\n", date)); result.append(utilities::string::va("Date: %s GMT\r\n", date));
result.append(utils::string::va("Content-Length: %d\r\n\r\n", buffer.GetLength())); result.append(utilities::string::va("Content-Length: %d\r\n\r\n", buffer.GetLength()));
result.append(buffer.GetString(), buffer.GetLength()); result.append(buffer.GetString(), buffer.GetLength());
raw_reply reply(result); raw_reply reply(result);

4
source/proxy-dll/demonware/servers/base_server.cpp
View File

@ -1,13 +1,13 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "base_server.hpp" #include "base_server.hpp"
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
namespace demonware namespace demonware
{ {
base_server::base_server(std::string name): name_(std::move(name)) base_server::base_server(std::string name): name_(std::move(name))
{ {
this->address_ = utils::cryptography::jenkins_one_at_a_time::compute(this->name_); this->address_ = utilities::cryptography::jenkins_one_at_a_time::compute(this->name_);
} }
const std::string& base_server::get_name() const const std::string& base_server::get_name() const

6
source/proxy-dll/demonware/servers/lobby_server.cpp
View File

@ -4,7 +4,7 @@
#include "../services.hpp" #include "../services.hpp"
#include "../keys.hpp" #include "../keys.hpp"
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
namespace demonware namespace demonware
{ {
@ -127,7 +127,7 @@ namespace demonware
char hash[8]; char hash[8];
std::memcpy(hash, &(enc.data()[enc.size() - 8]), 8); std::memcpy(hash, &(enc.data()[enc.size() - 8]), 8);
std::string dec = utils::cryptography::aes::decrypt( std::string dec = utilities::cryptography::aes::decrypt(
std::string(enc.data(), enc.size() - 8), std::string(seed, 16), std::string(enc.data(), enc.size() - 8), std::string(seed, 16),
demonware::get_decrypt_key()); demonware::get_decrypt_key());
@ -168,7 +168,7 @@ namespace demonware
} }
else else
{ {
logger::write(logger::LOG_TYPE_DEBUG, "[DW]: [lobby]: missing service '%s'", utils::string::va("%d", id)); logger::write(logger::LOG_TYPE_DEBUG, "[DW]: [lobby]: missing service '%s'", utilities::string::va("%d", id));
// return no error // return no error
byte_buffer buffer(data); byte_buffer buffer(data);

6
source/proxy-dll/demonware/servers/tcp_server.hpp
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "base_server.hpp" #include "base_server.hpp"
#include <utils/concurrency.hpp> #include <utilities/concurrency.hpp>
namespace demonware namespace demonware
{ {
@ -21,7 +21,7 @@ namespace demonware
void send(const std::string& data); void send(const std::string& data);
private: private:
utils::concurrency::container<data_queue> in_queue_; utilities::concurrency::container<data_queue> in_queue_;
utils::concurrency::container<stream_queue> out_queue_; utilities::concurrency::container<stream_queue> out_queue_;
}; };
} }

6
source/proxy-dll/demonware/servers/udp_server.hpp
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "base_server.hpp" #include "base_server.hpp"
#include <utils/concurrency.hpp> #include <utilities/concurrency.hpp>
namespace demonware namespace demonware
{ {
@ -56,7 +56,7 @@ namespace demonware
using out_queue = std::queue<out_packet>; using out_queue = std::queue<out_packet>;
using socket_queue_map = std::unordered_map<SOCKET, out_queue>; using socket_queue_map = std::unordered_map<SOCKET, out_queue>;
utils::concurrency::container<in_queue> in_queue_; utilities::concurrency::container<in_queue> in_queue_;
utils::concurrency::container<socket_queue_map> out_queue_; utilities::concurrency::container<socket_queue_map> out_queue_;
}; };
} }

2
source/proxy-dll/demonware/service.hpp
View File

@ -1,5 +1,5 @@
#pragma once #pragma once
#include <utils/string.hpp> #include <utilities/string.hpp>
#include "servers/service_server.hpp" #include "servers/service_server.hpp"
namespace demonware namespace demonware

2
source/proxy-dll/demonware/services/bdDML.cpp
View File

@ -1,7 +1,7 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "../services.hpp" #include "../services.hpp"
#include <utils/io.hpp> #include <utilities/io.hpp>
namespace demonware namespace demonware
{ {

12
source/proxy-dll/demonware/services/bdObjectStore.cpp
View File

@ -3,8 +3,8 @@
#include "../objects.hpp" #include "../objects.hpp"
#include <picoproto.h> #include <picoproto.h>
#include <utils/io.hpp> #include <utilities/io.hpp>
#include <utils/cryptography.hpp> #include <utilities/cryptography.hpp>
#include <component/platform.hpp> #include <component/platform.hpp>
namespace demonware namespace demonware
@ -109,10 +109,10 @@ namespace demonware
std::string url = request_buffer.GetString(2); std::string url = request_buffer.GetString(2);
std::string data = request_buffer.GetString(3); std::string data = request_buffer.GetString(3);
std::string file = utils::string::split(url, '/')[8]; std::string file = utilities::string::split(url, '/')[8];
std::string path = get_user_file_path(file); std::string path = get_user_file_path(file);
if (!utils::io::write_file(path, data)) if (!utilities::io::write_file(path, data))
logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObject] error on writing '%s'", file.data()); logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObject] error on writing '%s'", file.data());
else else
logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObject] saved user file '%s'", file.data()); logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObject] saved user file '%s'", file.data());
@ -147,12 +147,12 @@ namespace demonware
const rapidjson::Value& name = objects[i]["metadata"]["name"]; const rapidjson::Value& name = objects[i]["metadata"]["name"];
const rapidjson::Value& checksum = objects[i]["metadata"]["checksum"]; const rapidjson::Value& checksum = objects[i]["metadata"]["checksum"];
std::string data = utils::cryptography::base64::decode(content.GetString()); std::string data = utilities::cryptography::base64::decode(content.GetString());
const auto path = std::format("{}/{}", platform::get_userdata_directory(), name.GetString()); const auto path = std::format("{}/{}", platform::get_userdata_directory(), name.GetString());
uploaded_objects_list.push_back(name.GetString()); uploaded_objects_list.push_back(name.GetString());
if (!utils::io::write_file(path, data)) if (!utilities::io::write_file(path, data))
logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObjectsVectorized] error on writing '%s'", name.GetString()); logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObjectsVectorized] error on writing '%s'", name.GetString());
else else
logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObjectsVectorized] saved user file '%s'", name.GetString()); logger::write(logger::LOG_TYPE_DEBUG, "[bdObjectStore::uploadUserObjectsVectorized] saved user file '%s'", name.GetString());

6
source/proxy-dll/demonware/services/bdProfiles.cpp
View File

@ -1,7 +1,7 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "../services.hpp" #include "../services.hpp"
#include <utils/io.hpp> #include <utilities/io.hpp>
#include <component/platform.hpp> #include <component/platform.hpp>
namespace demonware namespace demonware
@ -27,7 +27,7 @@ namespace demonware
result->m_entityID = entity_id; result->m_entityID = entity_id;
result->m_VERSION = 4; result->m_VERSION = 4;
if (utils::io::read_file(std::format("{}/profileInfo_{}", platform::get_userdata_directory(), entity_id), &result->m_ddl)) if (utilities::io::read_file(std::format("{}/profileInfo_{}", platform::get_userdata_directory(), entity_id), &result->m_ddl))
{ {
auto reply = server->create_reply(this->task_id()); auto reply = server->create_reply(this->task_id());
reply->add(result); reply->add(result);
@ -46,7 +46,7 @@ namespace demonware
buffer->read_int32(&version); buffer->read_int32(&version);
buffer->read_blob(&ddl); buffer->read_blob(&ddl);
utils::io::write_file(std::format("{}/profileInfo_{}", platform::get_userdata_directory(), platform::bnet_get_userid()), ddl); utilities::io::write_file(std::format("{}/profileInfo_{}", platform::get_userdata_directory(), platform::bnet_get_userid()), ddl);
auto reply = server->create_reply(this->task_id()); auto reply = server->create_reply(this->task_id());
reply->send(); reply->send();

2
source/proxy-dll/loader/component_loader.cpp
View File

@ -1,7 +1,7 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "component_loader.hpp" #include "component_loader.hpp"
#include <utils/nt.hpp> #include <utilities/nt.hpp>
void component_loader::register_component(std::unique_ptr<component_interface>&& component_) void component_loader::register_component(std::unique_ptr<component_interface>&& component_)
{ {

34
source/proxy-dll/main.cpp
View File

@ -1,11 +1,11 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include <utils/io.hpp> #include <utilities/io.hpp>
#include <utils/nt.hpp> #include <utilities/nt.hpp>
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <utils/string.hpp> #include <utilities/string.hpp>
#include <utils/finally.hpp> #include <utilities/finally.hpp>
namespace namespace
{ {
@ -17,7 +17,7 @@ namespace
std::pair<void**, void*> patch_import(const std::string& lib, const std::string& func, void* function) std::pair<void**, void*> patch_import(const std::string& lib, const std::string& func, void* function)
{ {
static const utils::nt::library game{}; static const utilities::nt::library game{};
const auto game_entry = game.get_iat_entry(lib, func); const auto game_entry = game.get_iat_entry(lib, func);
if (!game_entry) if (!game_entry)
@ -26,11 +26,11 @@ namespace
} }
#ifdef DEBUG #ifdef DEBUG
logger::write(logger::LOG_TYPE_DEBUG, "[ IAT-HOOKS ]: Diverted %s::%s from %p to %p", utils::string::to_upper(lib).c_str(), func.c_str(), game_entry, function); logger::write(logger::LOG_TYPE_DEBUG, "[ IAT-HOOKS ]: Diverted %s::%s from %p to %p", utilities::string::to_upper(lib).c_str(), func.c_str(), game_entry, function);
#endif // DEBUG #endif // DEBUG
const auto original_import = game_entry; const auto original_import = game_entry;
utils::hook::set(game_entry, function); utilities::hook::set(game_entry, function);
return { game_entry, original_import }; return { game_entry, original_import };
} }
@ -49,17 +49,17 @@ namespace
{ {
patch_import("user32.dll", "GetSystemMetrics", get_system_metrics); patch_import("user32.dll", "GetSystemMetrics", get_system_metrics);
//utils::hook::set(utils::nt::library{}.get_iat_entry("kernel32.dll", "ExitProcess"), exit_hook); //utilities::hook::set(utilities::nt::library{}.get_iat_entry("kernel32.dll", "ExitProcess"), exit_hook);
} }
void remove_crash_file() void remove_crash_file()
{ {
const utils::nt::library game{}; const utilities::nt::library game{};
const auto game_file = game.get_path(); const auto game_file = game.get_path();
auto game_path = std::filesystem::path(game_file); auto game_path = std::filesystem::path(game_file);
game_path.replace_extension(".start"); game_path.replace_extension(".start");
utils::io::remove_file(game_path.generic_string()); utilities::io::remove_file(game_path.generic_string());
} }
bool run() bool run()
@ -68,7 +68,7 @@ namespace
{ {
auto premature_shutdown = true; auto premature_shutdown = true;
const auto _ = utils::finally([&premature_shutdown]() const auto _ = utilities::finally([&premature_shutdown]()
{ {
if (premature_shutdown) if (premature_shutdown)
{ {
@ -107,14 +107,14 @@ namespace
: source_(source) : source_(source)
{ {
memcpy(this->data_, source, sizeof(this->data_)); memcpy(this->data_, source, sizeof(this->data_));
utils::hook::jump(this->source_, target, true, true); utilities::hook::jump(this->source_, target, true, true);
} }
~patch() ~patch()
{ {
if (source_) if (source_)
{ {
utils::hook::copy(this->source_, this->data_, sizeof(this->data_)); utilities::hook::copy(this->source_, this->data_, sizeof(this->data_));
} }
} }
@ -148,13 +148,13 @@ namespace
uint8_t* get_entry_point() uint8_t* get_entry_point()
{ {
const utils::nt::library game{}; const utilities::nt::library game{};
return game.get_ptr() + game.get_optional_header()->AddressOfEntryPoint; return game.get_ptr() + game.get_optional_header()->AddressOfEntryPoint;
} }
std::vector<uint8_t*> get_tls_callbacks() std::vector<uint8_t*> get_tls_callbacks()
{ {
const utils::nt::library game{}; const utilities::nt::library game{};
const auto& entry = game.get_optional_header()->DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS]; const auto& entry = game.get_optional_header()->DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS];
if (!entry.VirtualAddress || !entry.Size) if (!entry.VirtualAddress || !entry.Size)
{ {
@ -222,7 +222,7 @@ HRESULT D3D11CreateDevice(void* adapter, const uint64_t driver_type,
char dir[MAX_PATH]{ 0 }; char dir[MAX_PATH]{ 0 };
GetSystemDirectoryA(dir, sizeof(dir)); GetSystemDirectoryA(dir, sizeof(dir));
const auto d3d11 = utils::nt::library::load(dir + "/d3d11.dll"s); const auto d3d11 = utilities::nt::library::load(dir + "/d3d11.dll"s);
return d3d11.get_proc<decltype(&D3D11CreateDevice)>("D3D11CreateDevice"); return d3d11.get_proc<decltype(&D3D11CreateDevice)>("D3D11CreateDevice");
}(); }();

14
source/proxy-dll/spoofer/spoofcall.cpp
View File

@ -1,6 +1,6 @@
#include <std_include.hpp> #include <std_include.hpp>
#include <utils/hook.hpp> #include <utilities/hook.hpp>
#include <stack> #include <stack>
namespace spoofcall namespace spoofcall
@ -30,7 +30,7 @@ namespace spoofcall
return res; return res;
} }
void callstack_return_stub(utils::hook::assembler& a) void callstack_return_stub(utilities::hook::assembler& a)
{ {
a.push(rax); a.push(rax);
a.pushad64(); a.pushad64();
@ -49,14 +49,14 @@ namespace spoofcall
{ {
const auto placeholder = 0x1403CF1C6_g; const auto placeholder = 0x1403CF1C6_g;
utils::hook::set<uint8_t>(placeholder - 2, 0xFF); // fakes a call utilities::hook::set<uint8_t>(placeholder - 2, 0xFF); // fakes a call
utils::hook::nop(placeholder, 1); utilities::hook::nop(placeholder, 1);
utils::hook::jump(placeholder + 1, utils::hook::assemble(callstack_return_stub)); utilities::hook::jump(placeholder + 1, utilities::hook::assemble(callstack_return_stub));
return placeholder; return placeholder;
} }
void callstack_stub(utils::hook::assembler& a) void callstack_stub(utilities::hook::assembler& a)
{ {
a.push(rax); a.push(rax);
@ -83,7 +83,7 @@ namespace spoofcall
static bool spoofer_initialized = false; static bool spoofer_initialized = false;
if (!spoofer_initialized) if (!spoofer_initialized)
{ {
callstack_proxy_addr = utils::hook::assemble(callstack_stub); callstack_proxy_addr = utilities::hook::assemble(callstack_stub);
} }
address_to_call = funcAddr; address_to_call = funcAddr;

4
source/proxy-dll/std_include.cpp
View File

@ -1,5 +1,5 @@
#include <std_include.hpp> #include <std_include.hpp>
#include <utils/nt.hpp> #include <utilities/nt.hpp>
extern "C" extern "C"
{ {
@ -27,7 +27,7 @@ extern "C"
size_t get_base() size_t get_base()
{ {
static auto base = size_t(utils::nt::library{}.get_ptr()); static auto base = size_t(utilities::nt::library{}.get_ptr());
assert(base && "Failed to resolve base"); assert(base && "Failed to resolve base");
return base; return base;
} }

2
source/shared-code/exception/minidump.cpp
View File

@ -79,7 +79,7 @@ namespace exception
std::string create_minidump(const LPEXCEPTION_POINTERS exceptioninfo) std::string create_minidump(const LPEXCEPTION_POINTERS exceptioninfo)
{ {
const utils::nt::handle file_handle = write_dump_to_temp_file(exceptioninfo); const utilities::nt::handle file_handle = write_dump_to_temp_file(exceptioninfo);
return read_file(file_handle); return read_file(file_handle);
} }
} }

2
source/shared-code/exception/minidump.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "../utils/nt.hpp" #include "../utilities/nt.hpp"
namespace exception namespace exception
{ {

2
source/shared-code/utils/binary_resource.cpp → source/shared-code/utilities/binary_resource.cpp
View File

@ -4,7 +4,7 @@
#include "nt.hpp" #include "nt.hpp"
#include "io.hpp" #include "io.hpp"
namespace utils namespace utilities
{ {
namespace namespace
{ {

2
source/shared-code/utils/binary_resource.hpp → source/shared-code/utilities/binary_resource.hpp
View File

@ -2,7 +2,7 @@
#include <string> #include <string>
namespace utils namespace utilities
{ {
class binary_resource class binary_resource
{ {

2
source/shared-code/utils/com.cpp → source/shared-code/utilities/com.cpp
View File

@ -8,7 +8,7 @@
#include <ShlObj.h> #include <ShlObj.h>
namespace utils::com namespace utilities::com
{ {
namespace namespace
{ {

2
source/shared-code/utils/com.hpp → source/shared-code/utilities/com.hpp
View File

@ -4,7 +4,7 @@
#include <ShlObj.h> #include <ShlObj.h>
#include <atlbase.h> #include <atlbase.h>
namespace utils::com namespace utilities::com
{ {
bool select_folder(std::string& out_folder, const std::string& title = "Select a Folder", const std::string& selected_folder = {}); bool select_folder(std::string& out_folder, const std::string& title = "Select a Folder", const std::string& selected_folder = {});
CComPtr<IProgressDialog> create_progress_dialog(); CComPtr<IProgressDialog> create_progress_dialog();

2
source/shared-code/utils/compression.cpp → source/shared-code/utilities/compression.cpp
View File

@ -8,7 +8,7 @@
#include "io.hpp" #include "io.hpp"
#include "finally.hpp" #include "finally.hpp"
namespace utils::compression namespace utilities::compression
{ {
namespace zlib namespace zlib
{ {

2
source/shared-code/utils/compression.hpp → source/shared-code/utilities/compression.hpp
View File

@ -5,7 +5,7 @@
#define CHUNK 16384u #define CHUNK 16384u
namespace utils::compression namespace utilities::compression
{ {
namespace zlib namespace zlib
{ {

2
source/shared-code/utils/concurrency.hpp → source/shared-code/utilities/concurrency.hpp
View File

@ -2,7 +2,7 @@
#include <mutex> #include <mutex>
namespace utils::concurrency namespace utilities::concurrency
{ {
template <typename T, typename MutexType = std::mutex> template <typename T, typename MutexType = std::mutex>
class container class container

2
source/shared-code/utils/cryptography.cpp → source/shared-code/utilities/cryptography.cpp
View File

@ -8,7 +8,7 @@ using namespace std::string_literals;
/// http://www.opensource.apple.com/source/CommonCrypto/CommonCrypto-55010/Source/libtomcrypt/doc/libTomCryptDoc.pdf /// http://www.opensource.apple.com/source/CommonCrypto/CommonCrypto-55010/Source/libtomcrypt/doc/libTomCryptDoc.pdf
namespace utils::cryptography namespace utilities::cryptography
{ {
namespace namespace
{ {

2
source/shared-code/utils/cryptography.hpp → source/shared-code/utilities/cryptography.hpp
View File

@ -5,7 +5,7 @@
#include <xxhash32.h> #include <xxhash32.h>
#include <xxhash64.h> #include <xxhash64.h>
namespace utils::cryptography namespace utilities::cryptography
{ {
namespace ecc namespace ecc
{ {

2
source/shared-code/utils/finally.hpp → source/shared-code/utilities/finally.hpp
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <type_traits> #include <type_traits>
namespace utils namespace utilities
{ {
/* /*
* Copied from here: https://github.com/microsoft/GSL/blob/e0880931ae5885eb988d1a8a57acf8bc2b8dacda/include/gsl/util#L57 * Copied from here: https://github.com/microsoft/GSL/blob/e0880931ae5885eb988d1a8a57acf8bc2b8dacda/include/gsl/util#L57

2
source/shared-code/utils/flags.cpp → source/shared-code/utilities/flags.cpp
View File

@ -4,7 +4,7 @@
#include <shellapi.h> #include <shellapi.h>
namespace utils::flags namespace utilities::flags
{ {
void parse_flags(std::vector<std::string>& flags) void parse_flags(std::vector<std::string>& flags)
{ {

2
source/shared-code/utils/flags.hpp → source/shared-code/utilities/flags.hpp
View File

@ -2,7 +2,7 @@
#include <string> #include <string>
namespace utils::flags namespace utilities::flags
{ {
bool has_flag(const std::string& flag); bool has_flag(const std::string& flag);
} }

2
source/shared-code/utils/hardware_breakpoint.cpp → source/shared-code/utilities/hardware_breakpoint.cpp
View File

@ -1,7 +1,7 @@
#include "hardware_breakpoint.hpp" #include "hardware_breakpoint.hpp"
#include "thread.hpp" #include "thread.hpp"
namespace utils::hardware_breakpoint namespace utilities::hardware_breakpoint
{ {
namespace namespace
{ {

2
source/shared-code/utils/hardware_breakpoint.hpp → source/shared-code/utilities/hardware_breakpoint.hpp
View File

@ -2,7 +2,7 @@
#include <thread> #include <thread>
#include "nt.hpp" #include "nt.hpp"
namespace utils::hardware_breakpoint namespace utilities::hardware_breakpoint
{ {
enum condition enum condition
{ {

2
source/shared-code/utils/hook.cpp → source/shared-code/utilities/hook.cpp
View File

@ -15,7 +15,7 @@
#undef min #undef min
#endif #endif
namespace utils::hook namespace utilities::hook
{ {
namespace namespace
{ {

2
source/shared-code/utils/hook.hpp → source/shared-code/utilities/hook.hpp
View File

@ -6,7 +6,7 @@
using namespace asmjit::x86; using namespace asmjit::x86;
namespace utils::hook namespace utilities::hook
{ {
namespace detail namespace detail
{ {

2
source/shared-code/utils/http.cpp → source/shared-code/utilities/http.cpp
View File

@ -2,7 +2,7 @@
#include "nt.hpp" #include "nt.hpp"
#include <atlcomcli.h> #include <atlcomcli.h>
namespace utils::http namespace utilities::http
{ {
std::optional<std::string> get_data(const std::string& url) std::optional<std::string> get_data(const std::string& url)
{ {

2
source/shared-code/utils/http.hpp → source/shared-code/utilities/http.hpp
View File

@ -4,7 +4,7 @@
#include <optional> #include <optional>
#include <future> #include <future>
namespace utils::http namespace utilities::http
{ {
std::optional<std::string> get_data(const std::string& url); std::optional<std::string> get_data(const std::string& url);
std::future<std::optional<std::string>> get_data_async(const std::string& url); std::future<std::optional<std::string>> get_data_async(const std::string& url);

4
source/shared-code/utils/identity.cpp → source/shared-code/utilities/identity.cpp
View File

@ -6,7 +6,7 @@
#include <intrin.h> #include <intrin.h>
#include <lmcons.h> #include <lmcons.h>
namespace utils::identity namespace utilities::identity
{ {
namespace namespace
{ {
@ -44,7 +44,7 @@ namespace utils::identity
std::string parse_uuid(const uint8_t* data) std::string parse_uuid(const uint8_t* data)
{ {
if (utils::memory::is_set(data, 0, 16) || utils::memory::is_set(data, -1, 16)) if (utilities::memory::is_set(data, 0, 16) || utilities::memory::is_set(data, -1, 16))
{ {
return {}; return {};
} }

2
source/shared-code/utils/identity.hpp → source/shared-code/utilities/identity.hpp
View File

@ -2,7 +2,7 @@
#include <string> #include <string>
namespace utils::identity namespace utilities::identity
{ {
std::string get_sys_username(); std::string get_sys_username();
std::string get_sys_uuid(); std::string get_sys_uuid();

2
source/shared-code/utils/image.cpp → source/shared-code/utilities/image.cpp
View File

@ -10,7 +10,7 @@
#include "finally.hpp" #include "finally.hpp"
namespace utils::image namespace utilities::image
{ {
image load_image(const std::string& data) image load_image(const std::string& data)
{ {

2
source/shared-code/utils/image.hpp → source/shared-code/utilities/image.hpp
View File

@ -3,7 +3,7 @@
#include <string> #include <string>
#include "nt.hpp" #include "nt.hpp"
namespace utils::image namespace utilities::image
{ {
struct image struct image
{ {

2
source/shared-code/utils/info_string.cpp → source/shared-code/utilities/info_string.cpp
View File

@ -1,7 +1,7 @@
#include "info_string.hpp" #include "info_string.hpp"
#include "string.hpp" #include "string.hpp"
namespace utils namespace utilities
{ {
info_string::info_string(const std::string& buffer) info_string::info_string(const std::string& buffer)
{ {

2
source/shared-code/utils/info_string.hpp → source/shared-code/utilities/info_string.hpp
View File

@ -3,7 +3,7 @@
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
namespace utils namespace utilities
{ {
class info_string class info_string
{ {

16
source/shared-code/utils/io.cpp → source/shared-code/utilities/io.cpp
View File

@ -2,7 +2,7 @@
#include "nt.hpp" #include "nt.hpp"
#include <fstream> #include <fstream>
namespace utils::io namespace utilities::io
{ {
bool remove_file(const std::string& file) bool remove_file(const std::string& file)
{ {
@ -86,6 +86,20 @@ namespace utils::io
return path.substr(pos + 1); return path.substr(pos + 1);
} }
std::string file_stem(const std::string& path)
{
std::filesystem::path fsp(path);
return fsp.stem().generic_string();
}
std::string file_extension(const std::string& path)
{
const auto pos = path.find_last_of('.');
if (pos == std::string::npos) return "";
return path.substr(pos + 1);
}
size_t file_size(const std::string& file) size_t file_size(const std::string& file)
{ {
if (file_exists(file)) if (file_exists(file))

4
source/shared-code/utils/io.hpp → source/shared-code/utilities/io.hpp
View File

@ -4,7 +4,7 @@
#include <vector> #include <vector>
#include <filesystem> #include <filesystem>
namespace utils::io namespace utilities::io
{ {
bool remove_file(const std::string& file); bool remove_file(const std::string& file);
bool move_file(const std::string& src, const std::string& target); bool move_file(const std::string& src, const std::string& target);
@ -13,6 +13,8 @@ namespace utils::io
bool read_file(const std::string& file, std::string* data); bool read_file(const std::string& file, std::string* data);
std::string read_file(const std::string& file); std::string read_file(const std::string& file);
std::string file_name(const std::string& path); std::string file_name(const std::string& path);
std::string file_stem(const std::string& path);
std::string file_extension(const std::string& path);
size_t file_size(const std::string& file); size_t file_size(const std::string& file);
time_t file_timestamp(const std::string& file); time_t file_timestamp(const std::string& file);
bool create_directory(const std::string& directory); bool create_directory(const std::string& directory);

2
source/shared-code/utils/json_config.cpp → source/shared-code/utilities/json_config.cpp
View File

@ -5,7 +5,7 @@
#include <rapidjson/stringbuffer.h> #include <rapidjson/stringbuffer.h>
#include <rapidjson/prettywriter.h> #include <rapidjson/prettywriter.h>
namespace utils::json_config namespace utilities::json_config
{ {
rapidjson::Document json_doc{}; rapidjson::Document json_doc{};
std::string file_name = "project-bo4.json"; std::string file_name = "project-bo4.json";

2
source/shared-code/utils/json_config.hpp → source/shared-code/utilities/json_config.hpp
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <string> #include <string>
namespace utils::json_config namespace utilities::json_config
{ {
bool ReadBoolean(const char* szSection, const char* szKey, bool bolDefaultValue); bool ReadBoolean(const char* szSection, const char* szKey, bool bolDefaultValue);
void WriteBoolean(const char* szSection, const char* szKey, bool bolValue); void WriteBoolean(const char* szSection, const char* szKey, bool bolValue);

4
source/shared-code/utils/memory.cpp → source/shared-code/utilities/memory.cpp
View File

@ -1,7 +1,7 @@
#include "memory.hpp" #include "memory.hpp"
#include "nt.hpp" #include "nt.hpp"
namespace utils namespace utilities
{ {
memory::allocator memory::mem_allocator_; memory::allocator memory::mem_allocator_;
@ -144,7 +144,7 @@ namespace utils
bool memory::is_rdata_ptr(void* pointer) bool memory::is_rdata_ptr(void* pointer)
{ {
const std::string rdata = ".rdata"; const std::string rdata = ".rdata";
const auto pointer_lib = utils::nt::library::get_by_address(pointer); const auto pointer_lib = utilities::nt::library::get_by_address(pointer);
for (const auto& section : pointer_lib.get_section_headers()) for (const auto& section : pointer_lib.get_section_headers())
{ {

2
source/shared-code/utils/memory.hpp → source/shared-code/utilities/memory.hpp
View File

@ -3,7 +3,7 @@
#include <mutex> #include <mutex>
#include <vector> #include <vector>
namespace utils namespace utilities
{ {
class memory final class memory final
{ {

4
source/shared-code/utils/nt.cpp → source/shared-code/utilities/nt.cpp
View File

@ -1,6 +1,6 @@
#include "nt.hpp" #include "nt.hpp"
namespace utils::nt namespace utilities::nt
{ {
library library::load(const char* name) library library::load(const char* name)
{ {
@ -251,7 +251,7 @@ namespace utils::nt
void relaunch_self() void relaunch_self()
{ {
const utils::nt::library self; const utilities::nt::library self;
STARTUPINFOA startup_info; STARTUPINFOA startup_info;
PROCESS_INFORMATION process_info; PROCESS_INFORMATION process_info;

2
source/shared-code/utils/nt.hpp → source/shared-code/utilities/nt.hpp
View File

@ -16,7 +16,7 @@
#include <functional> #include <functional>
#include <filesystem> #include <filesystem>
namespace utils::nt namespace utilities::nt
{ {
class library final class library final
{ {

10
source/shared-code/utils/progress_ui.cpp → source/shared-code/utilities/progress_ui.cpp
View File

@ -1,12 +1,12 @@
#include "progress_ui.hpp" #include "progress_ui.hpp"
#include <utils/string.hpp> #include "string.hpp"
namespace utils namespace utilities
{ {
progress_ui::progress_ui() progress_ui::progress_ui()
{ {
this->dialog_ = utils::com::create_progress_dialog(); this->dialog_ = utilities::com::create_progress_dialog();
if (!this->dialog_) if (!this->dialog_)
{ {
throw std::runtime_error{"Failed to create dialog"}; throw std::runtime_error{"Failed to create dialog"};
@ -30,12 +30,12 @@ namespace utils
void progress_ui::set_line(const int line, const std::string& text) const void progress_ui::set_line(const int line, const std::string& text) const
{ {
this->dialog_->SetLine(line, utils::string::convert(text).data(), false, nullptr); this->dialog_->SetLine(line, utilities::string::convert(text).data(), false, nullptr);
} }
void progress_ui::set_title(const std::string& title) const void progress_ui::set_title(const std::string& title) const
{ {
this->dialog_->SetTitle(utils::string::convert(title).data()); this->dialog_->SetTitle(utilities::string::convert(title).data());
} }
bool progress_ui::is_cancelled() const bool progress_ui::is_cancelled() const

2
source/shared-code/utils/progress_ui.hpp → source/shared-code/utilities/progress_ui.hpp
View File

@ -2,7 +2,7 @@
#include "com.hpp" #include "com.hpp"
namespace utils namespace utilities
{ {
class progress_ui class progress_ui
{ {

8
source/shared-code/utils/signature.cpp → source/shared-code/utilities/signature.cpp
View File

@ -13,7 +13,7 @@
#undef min #undef min
#endif #endif
namespace utils::hook namespace utilities::hook
{ {
void signature::load_pattern(const std::string& pattern) void signature::load_pattern(const std::string& pattern)
{ {
@ -143,7 +143,7 @@ namespace utils::hook
signature::signature_result signature::process() const signature::signature_result signature::process() const
{ {
//MessageBoxA(nullptr, utils::string::va("%llX(%llX)%llX", *this->start_ , this->start_, this->length_), "signature::process", MB_OK | MB_ICONINFORMATION); //MessageBoxA(nullptr, utilities::string::va("%llX(%llX)%llX", *this->start_ , this->start_, this->length_), "signature::process", MB_OK | MB_ICONINFORMATION);
const auto range = this->length_ - this->mask_.size(); const auto range = this->length_ - this->mask_.size();
const auto cores = std::max(1u, std::thread::hardware_concurrency()); const auto cores = std::max(1u, std::thread::hardware_concurrency());
@ -217,7 +217,7 @@ namespace utils::hook
} }
} }
utils::hook::signature::signature_result operator"" _sig(const char* str, const size_t len) utilities::hook::signature::signature_result operator"" _sig(const char* str, const size_t len)
{ {
return utils::hook::signature(std::string(str, len)).process(); return utilities::hook::signature(std::string(str, len)).process();
} }

4
source/shared-code/utils/signature.hpp → source/shared-code/utilities/signature.hpp
View File

@ -2,7 +2,7 @@
#include "nt.hpp" #include "nt.hpp"
#include <cstdint> #include <cstdint>
namespace utils::hook namespace utilities::hook
{ {
class signature final class signature final
{ {
@ -46,4 +46,4 @@ namespace utils::hook
}; };
} }
utils::hook::signature::signature_result operator"" _sig(const char* str, size_t len); utilities::hook::signature::signature_result operator"" _sig(const char* str, size_t len);

19
source/shared-code/utils/string.cpp → source/shared-code/utilities/string.cpp
View File

@ -1,11 +1,11 @@
#include "string.hpp" #include "string.hpp"
#include <sstream> #include <regex>
#include <cstdarg> #include <cstdarg>
#include <algorithm> #include <algorithm>
#include "nt.hpp" #include "nt.hpp"
namespace utils::string namespace utilities::string
{ {
const char* va(const char* fmt, ...) const char* va(const char* fmt, ...)
{ {
@ -71,6 +71,10 @@ namespace utils::string
return text; return text;
} }
bool is_integer(const std::string& str) {
return std::regex_match(str, std::regex("[(-|+)|][0-9]+"));
}
bool starts_with(const std::string& text, const std::string& substring) bool starts_with(const std::string& text, const std::string& substring)
{ {
return text.find(substring) == 0; return text.find(substring) == 0;
@ -213,4 +217,15 @@ namespace utils::string
if (!sensetive && (to_lower(s1) == to_lower(s2))) return true; if (!sensetive && (to_lower(s1) == to_lower(s2))) return true;
return false; return false;
} }
bool contains(std::string text, std::string substr, bool sensetive)
{
if (!sensetive) {
text = to_lower(text);
substr = to_lower(substr);
}
if (text.find(substr) != std::string::npos) return true;
return false;
}
} }

6
source/shared-code/utils/string.hpp → source/shared-code/utilities/string.hpp
View File

@ -7,7 +7,7 @@ template <class Type, size_t n>
size_t ARRAYSIZE(Type (&)[n]) { return n; } size_t ARRAYSIZE(Type (&)[n]) { return n; }
#endif #endif
namespace utils::string namespace utilities::string
{ {
template <size_t Buffers, size_t MinBufferSize> template <size_t Buffers, size_t MinBufferSize>
class va_provider final class va_provider final
@ -85,6 +85,9 @@ namespace utils::string
std::string to_lower(std::string text); std::string to_lower(std::string text);
std::string to_upper(std::string text); std::string to_upper(std::string text);
bool is_integer(const std::string& str);
bool starts_with(const std::string& text, const std::string& substring); bool starts_with(const std::string& text, const std::string& substring);
bool ends_with(const std::string& text, const std::string& substring); bool ends_with(const std::string& text, const std::string& substring);
@ -101,4 +104,5 @@ namespace utils::string
double match(const std::string& input, const std::string& text); double match(const std::string& input, const std::string& text);
bool compare(const std::string& s1, const std::string& s2, bool sensetive = false); bool compare(const std::string& s1, const std::string& s2, bool sensetive = false);
bool contains(std::string text, std::string substr, bool sensetive = false);
} }

4
source/shared-code/utils/thread.cpp → source/shared-code/utilities/thread.cpp
View File

@ -4,7 +4,7 @@
#include <TlHelp32.h> #include <TlHelp32.h>
namespace utils::thread namespace utilities::thread
{ {
bool set_name(const HANDLE t, const std::string& name) bool set_name(const HANDLE t, const std::string& name)
{ {
@ -28,7 +28,7 @@ namespace utils::thread
auto* const t = OpenThread(THREAD_SET_LIMITED_INFORMATION, FALSE, id); auto* const t = OpenThread(THREAD_SET_LIMITED_INFORMATION, FALSE, id);
if (!t) return false; if (!t) return false;
const auto _ = utils::finally([t]() const auto _ = utilities::finally([t]()
{ {
CloseHandle(t); CloseHandle(t);
}); });

2
source/shared-code/utils/thread.hpp → source/shared-code/utilities/thread.hpp
View File

@ -2,7 +2,7 @@
#include <thread> #include <thread>
#include "nt.hpp" #include "nt.hpp"
namespace utils::thread namespace utilities::thread
{ {
bool set_name(HANDLE t, const std::string& name); bool set_name(HANDLE t, const std::string& name);
bool set_name(DWORD id, const std::string& name); bool set_name(DWORD id, const std::string& name);