Реверс-инжиниринг популярного античита BattlEye | ДОСТУПНЫЙ ОТДЫХ
Реверс-инжиниринг популярного античита BattlEye
Интересное

Реверс-инжиниринг популярного античита BattlEye

Реверс-инжиниринг популярного античита BattlEye
BattlEye — это преимущетвенно немецкий сторонний античит, в основном разрабатываемый 32-летним Бастианом Хейко Сутером. Он предоставляет (или пытается предоставить) издателям игр простую в применении систему античита, использующую механизмы общей защиты, а также обнаружение читов для конкретных игр для оптимизации безопасности. Как сказано на веб-сайте продукта, он всегда остаётся на вершине современных технологий и использует инновационные методики защиты и обнаружения; очевидно, это следствие национальности разработчика: QUALITY MADE IN GERMANY. BattlEye состоит из множества элементов, совместно работающих над поиском читеров в играх, оплативших использование продукта. Четырьмя основными элементами являются:

  • BEService
    • Системная служба Windows, обменивающаяся данными с сервером BattlEye BEServer, который обеспечивает возможности клиент-серверной связи с BEDaisy и BEClient.
  • BEDaisy
    • Драйвер ядра Windows, регистрирующий превентивные механизмы обработки событий и мини-фильтры, чтобы препятствовать читерам в незаконном изменении игры
  • BEClient
    • Динамически подключаемая библиотека Windows, отвечающая за большинство векторов обнаружения, в том числе за описанные в данной статье. После инициализации она привязывается к процессу игры.
  • BEServer
    • Проприетарный бэкенд-сервер, отвечающий за сбор информации и принятие конкретных мер против читеров.

Шелл-код
Недавно в Интернете всплыл дамп шелл-кода BattlEye, и мы решили написать о том, что же конкретно ищет текущая версия BattlEye. Мы не анализировали BattlEye целых шесть месяцев, поэтому наш последний дамп шелл-кода скорее всего уже устарел. Различные части кода восстанавливали только по памяти из этого последнего дампа, предположив, что в BattlEye дополняется только шелл-код и не удаляются предыдущие процедуры обнаружения.

Как?
BattlEye предположительно выполняет потоковую передачу шелл-кода со своего сервера в службу Windows под названием BEService. Эта служба обменивается данными с модулем BEClient, расположенным внутри процесса игры. Обмен данными выполняется через конвейер .namedpipeBattleye и до 2018 года был незашифрованным. Теперь все передаваемые данные шифруются xor-шифровальщиком с очень маленькими ключами, из-за чего чрезвычайно просто выполнять известные атаки на основе открытых текстов (plaintext attacks). Когда шелл-код передаётся клиенту, он располагается и выполняется за пределами всех известных модулей, из-за чего его легко определить. Для создания дампа шелл-кода можно или обрабатывать стандартные функции Windows API типа CreateFile, ReadFile и т.п., и выполнять дамп соответствующей области памяти всех вызывающих модулей (запрашивая информацию о памяти по возвращаемому адресу), находящихся за пределами всех известных модулей, или периодически сканировать пространство виртуальной памяти игры в поисках исполняемой памяти за пределами всех известных модулей, и дампить её на диск. При этом нужно отслеживать, дамп каких областей уже был выполнен, чтобы в результате не получилось множество одинаковых дампов.

Объяснение
Представленные в статье фрагменты псевдокода сильно модифицированы ради красоты. Вы не сможете сдампить шелл-код BattlEye и сразу же узнать эти части; шелл-код не содержит вызовов функций, а многие алгоритмы в статье развёрнуты. Но на самом деле это не важно, потому что когда вы закончите читать об этом ужасном античите, вам представится возможность обойти его (:

Перебирание памяти
Самый распространённый механизм обнаружения в античитах — это перебирание (memory enumeration) и сканирование памяти для поиска известных образов читов. Он легко реализуем и, как показало прошлое, при правильном подходе достаточно эффективен, если вы не забыли основы ассемблера и занесли в чёрный список пролог общей функции.

Battleye перебирает всё адресное пространство процесса игры (текущего процесса в данном контексте) и выполняет различные проверки на предмет исполняемости страницы и нахождения за пределами соответствующего пространства памяти шелл-кода.

Вот как это реализовано в Battleye:

// MEMORY ENUMERATION
for (current_address = 0
// QUERY MEMORY_BASIC_INFORMATION
NtQueryVirtualMemory(GetCurrentProcess(), current_address, 0, &memory_information, 0x30, &return_length) >= 0
current_address = memory_information.base_address + memory_information.region_size)
{

const auto outside_of_shellcode =
memory_information.base_address > shellcode_entry ||
memory_information.base_address + memory_information.region_size <= shellcode_entry

const auto executable_memory =
memory_information.state == MEM_COMMIT &&
(memory_information.protect == PAGE_EXECUTE ||
memory_information.protect == PAGE_EXECUTE_READ ||
memory_information.protect == PAGE_EXECUTE_READWRITE

const auto unknown_whitelist =
memory_information.protect != PAGE_EXECUTE_READWRITE ||
memory_information.region_size != 100000000

if (!executable_memory || !outside_of_shellcode || !unknown_whitelist)
continue

// RUN CHECKS
memory::anomaly_check(memory_information

memory::pattern_check(current_address, memory_information

memory::module_specific_check_microsoft(memory_information

memory::guard_check(current_address, memory_information

memory::module_specific_check_unknown(memory_information
}
Аномалии памяти
BattlEye помечает все аномалии в адресном пространстве памяти, в основном памяти исполняемых модулей, не соответствующей загруженному образу:

void memory::anomaly_check(MEMORY_BASIC_INFORMATION memory_information)
{
// REPORT ANY EXECUTABLE PAGE OUTSIDE OF KNOWN MODULES
if (memory_information.type == MEM_PRIVATE || memory_information.type == MEM_MAPPED)
{
if ((memory_information.base_address & 0xFF0000000000) != 0x7F0000000000 && // UPPER EQUALS 0x7F
(memory_information.base_address & 0xFFF000000000) != 0x7F000000000 && // UPPER EQUALS 0x7F0
(memory_information.base_address & 0xFFFFF0000000) != 0x70000000 && // UPPER EQUALS 0x70000
memory_information.base_address != 0x3E0000))
{
memory_report.unknown = 0
memory_report.report_id = 0x2F
memory_report.base_address = memory_information.base_address
memory_report.region_size = memory_information.region_size
memory_report.memory_info =
memory_information.type |
memory_information.protect |
memory_information.state

battleye::report(&memory_report, sizeof(memory_report), 0
}
}
}
Сканирование в поисках паттернов
Как говорилось выше, BattlEye также сканирует память локальных процессов на наличие различных чётко прописанных паттернов, как это видно из показанной ниже реализации.

При чтении этого псевдокода вы можете догадаться, что эти проверки можно обойти переписыванием области кода каждого загруженного модуля, так как они не будут выполнять сканирования в поисках паттернов в известных образах. Чтобы не попасть на проверки целостности, нужно загружать все упакованные и помещённые в белый список области и переписывать области кода, помеченные как RWX, потому что мы не можем выполнять проверки целостности без эмуляции упаковщика. В текущей версии шелл-кода BattlEye эти паттерны памяти жёстко прописаны:

[05 18] ojectsPUBGChinese
[05 17] BattleGroundsPrivate_CheatESP
[05 17] [%.0fm] %s
[05 3E] 0000Neck0000Chest0000000Mouse 10
[05 3F] PlayerESPColor
[05 40] Aimbot: %d02D3E2041
[05 36] HackMachine
[05 4A] VisualHacks.net
[05 50] 3E232F653E31314E4E563D4276282A3A2E463F757523286752552E6F30584748
[05 4F] DLLInjection-masterx64Release
[05 52] NameESP
[05 48] Skullhack
[05 55] .rdata$zzzdbg
[05 39] AimBot
[05 39] EB4941803C123F755C623FEB388D41D0FBEC93C977583E930EB683E1DF
[05 5F] 55E9
[05 5F] 57E9
[05 5F] 60E9
[05 68] D3D11Present initialised
[05 6E] [ %.0fM ]
[05 74] [hp:%d]%dm
[05 36] 48836424380488D4C2458488B5424504C8BC848894C24304C8BC7488D4C2460
[05 36] 741FBA80000FF15607E0085C07510F2F1087801008B8788100EB
[05 36] 40F2AA156F8D2894E9AB4489535D34F9CPOSITION0000COL
[05 7A] FFE090
[05 79] %s00%d00POSITION0000COLOR0000000
[05 36] 8E85765DCDDA452E75BA12B4C7B94872116DB948A1DAA6B948A7676BB948902C
[05 8A] n<assembly xmlsn=’urn:schemas-mi
Эти паттерны памяти также содержат двухбайтный заголовок, а именно неизвестное статическое значение 05 и уникальный идентификатор.

Чего мы не увидим, так это того, что BattlEye также динамически выполняет потоковую передачу паттернов из BEServer и отправляет их в BEClient, но в статье мы рассматривать это не будем.

Читать  Реалистичные 3D-торты от Молли Роббинс (21 фото)

Они итеративно сканируются следующим алгоритмом:

void memory::pattern_check(void* current_address, MEMORY_BASIC_INFORMATION memory_information)
{
const auto is_user32 = memory_information.allocation_base == GetModuleHandleA(«user32.dll»

// ONLY SCAN PRIVATE MEMORY AND USER32 CODE SECTION
if (memory_information.type != MEM_PRIVATE && !is_user32)
continue

for (address = current_address
address != memory_information.base_address + memory_information.region_size
address += PAGE_SIZE) // PAGE_SIZE
{
// READ ENTIRE PAGE FROM LOCAL PROCESS INTO BUFFER
if (NtReadVirtualMemory(GetCurrentProcess(), address, buffer, PAGE_SIZE, 0) < 0)
continue

for (pattern_index = 0 pattern_index < 0x1C/*PATTERN COUNT*/ ++pattern_index)
{
if (pattern[pattern_index].header == 0x57A && !is_user32) // ONLY DO FFE090 SEARCHES WHEN IN USER32
continue

for (offset = 0 pattern[pattern_index].length + offset <= PAGE_SIZE ++offset)
{
const auto pattern_matches =
memory::pattern_match(&address[offset], pattern[pattern_index // BASIC PATTERN MATCH

if (pattern_matches)
{
// PATTERN FOUND IN MEMORY
pattern_report.unknown = 0
pattern_report.report_id = 0x35
pattern_report.type = pattern[index].header
pattern_report.data = &address[offset
pattern_report.base_address = memory_information.base_address
pattern_report.region_size = memory_information.region_size
pattern_report.memory_info =
memory_information.type |
memory_information.protect |
memory_information.state

battleye::report(&pattern_report, sizeof(pattern_report), 0
}
}
}
}
}
Проверка конкретных модулей (Microsoft)
Проверки модулей сообщают о наличии конкретных модулей, загруженных в процесс игры:

void memory::module_specific_check_microsoft(MEMORY_BASIC_INFORMATION memory_information)
{
auto executable =
memory_information.protect == PAGE_EXECUTE ||
memory_information.protect == PAGE_EXECUTE_READ ||
memory_information.protect == PAGE_EXECUTE_READWRITE

auto allocated =
memory_information.state == MEM_COMMIT

if (!allocated || !executable)
continue

auto mmres_handle = GetModuleHandleA(«mmres.dll»
auto mshtml_handle = GetModuleHandleA(«mshtml.dll»

if (mmres_handle && mmres_handle == memory_information.allocation_base)
{
battleye_module_anomaly_report module_anomaly_report
module_anomaly_report.unknown = 0
module_anomaly_report.report_id = 0x5B
module_anomaly_report.identifier = 0x3480
module_anomaly_report.region_size = memory_information.region_size
battleye::report(&module_anomaly_report, sizeof(module_anomaly_report), 0
}
else if (mshtml_handle && mshtml_handle == memory_information.allocation_base)
{
battleye_module_anomaly_report module_anomaly_report
module_anomaly_report.unknown = 0
module_anomaly_report.report_id = 0x5B
module_anomaly_report.identifier = 0xB480
module_anomaly_report.region_size = memory_information.region_size
battleye::report(&module_anomaly_report, sizeof(module_anomaly_report), 0
}
}
Проверка конкретных модулей (неизвестных)
В систему добавлена проверка конкретных модулей, сигнализирующая серверу о том, что у вас загружены модули, удовлетворяющие любому из этих критериев:

void memory::module_specific_check_unknown(MEMORY_BASIC_INFORMATION memory_information)
{
const auto dos_header = (DOS_HEADER*)module_handle
const auto pe_header = (PE_HEADER*)(module_handle + dos_header->e_lfanew

const auto is_image = memory_information.state == MEM_COMMIT && memory_information.type == MEM_IMAGE
if (!is_image)
return

const auto is_base = memory_information.base_address == memory_information.allocation_base
if (!is_base)
return

const auto match_1 =
time_date_stamp == 0x5B12C900 &&
*(__int8*)(memory_information.base_address + 0x1000) == 0x00 &&
*(__int32*)(memory_information.base_address + 0x501000) != 0x353E900

const auto match_2 =
time_date_stamp == 0x5A180C35 &&
*(__int8*)(memory_information.base_address + 0x1000) != 0x00

const auto match_2 =
time_date_stamp == 0xFC9B9325 &&
*(__int8*)(memory_information.base_address + 0x6D3000) != 0x00

if (!match_1 && !match_2 && !match_3)
return

const auto buffer_offset = 0x00 // OFFSET DEPENDS ON WHICH MODULE MATCHES, RESPECTIVELY 0x501000, 0x1000 AND 0x6D3000

unknown_module_report.unknown1 = 0
unknown_module_report.report_id = 0x46
unknown_module_report.unknown2 = 1
unknown_module_report.data = *(__int128*)(memory_information.base_address + buffer_offset
battleye::report(&unknown_module_report, sizeof(unknown_module_report), 0
}
Мы не знаем, какие модули удовлетворяют этим критериям, но подозреваем, что это попытка обнаружения очень ограниченного набора конкретных чит-модулей.

Дополнение: @how02 сообщил нам, что модуль action_x64.dll имеет метку времени 0x5B12C900 и содержит область кода, в которую можно выполнять запись; как и говорилось ранее, это можно использовать для эксплойта.

Защита памяти
В BattlEye также внедрена очень сомнительная процедура обнаружения, которая, по нашему мнению, ищет память с установленным флагом PAGE_GUARD, не проверяя на самом деле, установлен ли флаг PAGE_GUARD:

void memory::guard_check(void* current_address, MEMORY_BASIC_INFORMATION memory_information)
{
if (memory_information.protect != PAGE_NOACCESS)
{
auto bad_ptr = IsBadReadPtr(current_address, sizeof(temporary_buffer
auto read = NtReadVirtualMemory(
GetCurrentProcess(),
current_address,
temporary_buffer, sizeof(temporary_buffer),
0

if (read < 0 || bad_ptr)
{
auto query = NtQueryVirtualMemory(
GetCurrentProcess(),
current_address,
0,
&new_memory_information, sizeof(new_memory_information),
&return_length

memory_guard_report.guard =
query < 0 ||
new_memory_information.state != memory_information.state ||
new_memory_information.protect != memory_information.protect

if (memory_guard_report.guard)
{
memory_guard_report.unknown = 0
memory_guard_report.report_id = 0x21
memory_guard_report.base_address = memory_information.base_address
memory_guard_report.region_size = (int)memory_information.region_size
memory_guard_report.memory_info =
memory_information.type |
memory_information.protect |
memory_information.state

battleye::report(&memory_guard_report, sizeof(memory_guard_report), 0
}
}
}
}
Перебирание окон
Шелл-код BattlEye перебирает каждое из текущих видимых во время работы игры окон, обходя окна сверху вниз (по z-значению). Дескрипторы окон, находящиеся внутри процесса игры, исключаются из этого перебора, и это определяется вызовом GetWindowThreadProcessId. Следовательно, можно привязать соответствующую функцию к ложному владельцу окна, чтобы BattlEye не проверял ваше окно.

void window_handler::enumerate()
{
for (auto window_handle = GetTopWindow
window_handle
window_handle = GetWindow(window_handle, GW_HWNDNEXT), // GET WINDOW BELOW
++window_handler::windows_enumerated) // INCREMENT GLOBAL COUNT FOR LATER USAGE
{
auto window_process_pid = 0
GetWindowThreadProcessId(window_handle, &window_process_pid

if (window_process_pid == GetCurrentProcessId())
continue

// APPEND INFORMATION TO THE MISC. REPORT, THIS IS EXPLAINED LATER IN THE ARTICLE
window_handler::handle_summary(window_handle

constexpr auto max_character_count = 0x80
const auto length = GetWindowTextA(window_handle, window_title_report.window_title, max_character_count

// DOES WINDOW TITLE MATCH ANY OF THE BLACKLISTED TITLES?
if (!contains(window_title_report.window_title, «CheatAut») &&
!contains(window_title_report.window_title, «pubg_kh») &&
!contains(window_title_report.window_title, «conl -«) &&
!contains(window_title_report.window_title, «PerfectA») &&
!contains(window_title_report.window_title, «AIMWA») &&
!contains(window_title_report.window_title, «PUBG AIM») &&
!contains(window_title_report.window_title, «HyperChe»))
continue

// REPORT WINDOW
window_title_report.unknown_1 = 0
window_title_report.report_id = 0x33
battleye::report(&window_title_report, sizeof(window_title_report) + length, 0
}
}
Аномалия при перебирании
Если проверено меньше, чем два окна, серверу отправляется уведомление. Вероятно, это сделано для того, чтобы предотвратить патчинг соответствующих функций, не позволяющих шелл-коду BattlEye исследовать ни одно окно:

void window_handler::check_count()
{
if (window_handler::windows_enumerated > 1)
return

// WINDOW ENUMERATION FAILED, MOST LIKELY DUE TO HOOK
window_anomaly_report.unknown_1 = 0
window_anomaly_report.report_id = 0x44
window_anomaly_report.enumerated_windows = windows_enumerated
battleye::report(&window_anomaly_report, sizeof(window_anomaly_report), 0

}
Перебирание процессов
При помощи вызова CreateToolhelp32Snapshot BattlEye перебирает все запущенные процессы, но не обрабатывает никакие ошибки, благодаря чему очень легко пропатчить и избежать выполнения следующих процедур обнаружения:

Проверка пути
Если образ находится внутри как минимум двух подкаталогов (считая от корня диска), то система пометит процессы флагом, если путь к соответствующему образу содержит хотя бы одну из этих строк:

Desktop
Temp
FileRec
Documents
Downloads
Roaming
tmp.ex
notepad.
….
cmd.ex
Если путь к исполняемому файлу соответствует одной из этих строк, то сервер получает уведомление о пути к исполняемому файлу, а также информацию о том, является ли родительский процесс одним из следующих (содержит соответствующий бит флага, отправляемый серверу):

steam.exe [0x01]
explorer.exe [0x02]
lsass.exe [0x08]
cmd.exe [0x10]
Если клиент не может открыть дескриптор с соответствующими правами QueryLimitedInformation, то он установит бит флага 0x04, если причина ошибки при сбое вызова OpenProcess не равна ERROR_ACCESS_DENIED, что даёт нам последний контейнер перечисления для соответствующего значения флага:

enum BATTLEYE_PROCESS_FLAG
{
STEAM = 0x1,
EXPLORER = 0x2,
ERROR = 0x4,
LSASS = 0x8,
CMD = 0x10
}
Если родительским процессом является steam, то пользователю мгновенно устанавливается флаг и об этом сообщается серверу с id уведомления 0x40

Имя образа
Если процесс соответствует любому из множества представленных ниже критериев, то вам мгновенно устанавливается флаг и об этом сообщается серверу с id уведомления 0x38

Имя образа содержит «Loadlibr»
Имя образа содержит «Rng »
Имя образа содержит «A0E7FFFFFF81»
Имя образа содержит «RNG »
Имя образа содержит «90E54355»
Имя образа содержит «2.6.ex»
Имя образа содержит «TempFile.exe»
Оверлей игр Steam
BattlEye отслеживает процесс оверлея игр Steam, отвечающий за внутриигровой оверлей, известный большинству пользователей Steam. Полное имя хоста оверлея игр Steam — gameoverlayui.exe; известно, что его часто используют для эксплойтов рендеринга, потому что довольно легко взломать и выполнять незаконную отрисовку в окне игры. Проверка имеет следующее условие:

Читать  Российский самолет-амфибия Бе-200 разбился при заходе на посадку в Турции | Пикабу

file size != 0 && image name contains (case insensitive) gameoverlayu
Дальнейшие проверки, специфичные для оверлея игр Steam, практически аналогичны процедурам, выполняемым для самого процесса игры, поэтому в псевдокоде пропущены.

Сканирование памяти оверлея игр Steam
Процесс оверлея игр Steam сканируется на наличие паттернов и аномалий. Нам не удалось пробраться глубже в кроличью нору, и узнать, для чего эти паттерны, потому что они очень обобщённые и скорее всего связаны с модулями читов.

void gameoverlay::pattern_scan(MEMORY_BASIC_INFORMATION memory_information)
{
// PATTERNS:
// Home
// F1
// FFFF83C48C30000000000
// .pipe%s
// C760000C64730
// 60C01810033D2

// …
// PATTERN SCAN, ALMOST IDENTICAL CODE TO THE AFOREMENTIONED PATTERN SCANNING ROUTINE

gameoverlay_memory_report.unknown_1 = 0
gameoverlay_memory_report.report_id = 0x35
gameoverlay_memory_report.identifier = 0x56C
gameoverlay_memory_report.data = &buffer[offset
gameoverlay_memory_report.base_address = memory_information.base_address
gameoverlay_memory_report.region_size = (int)memory_information.region_size
gameoverlay_memory_report.memory_info =
memory_information.type |
memory_information.protect |
memory_information.state

battleye::report(&gameoverlay_memory_report, sizeof(gameoverlay_memory_report), 0
}
Процедура сканирования также ищет любые аномалии в виде исполняемого кода за пределами загруженных изображений, предполагая, что взломщики инъектировали код в процесс оверлея:

void gameoverlay::memory_anomaly_scan(MEMORY_BASIC_INFORMATION memory_information)
{
// …
// ALMOST IDENTICAL ANOMALY SCAN COMPARED TO MEMORY ENUMERATION ROUTINE OF GAME PROCESS

gameoverlay_report.unknown = 0
gameoverlay_report.report_id = 0x3B
gameoverlay_report.base_address = memory_information.base_address
gameoverlay_report.region_size = memory_information.region_size
gameoverlay_report.memory_info = memory_information.type | memory_information.protect | memory_information.state
battleye::report(&gameoverlay_report, sizeof(gameoverlay_report), 0
}
Защита процесса оверлея игр Steam
Если процесс оверлея игр Steam защищён какой-нибудь защитой процессов Windows наподобие Light (WinTcb), то сервер получит об этом уведомление.

void gameoverlay::protection_check(HANDLE process_handle)
{
auto process_protection = 0

NtQueryInformationProcess(
process_handle, ProcessProtectionInformation,
&process_protection, sizeof(process_protection), nullptr

if (process_protection == 0) // NO PROTECTION
return

gameoverlay_protected_report.unknown = 0
gameoverlay_protected_report.report_id = 0x35
gameoverlay_protected_report.identifier = 0x5B1
gameoverlay_protected_report.data = process_protection
battleye::report(&gameoverlay_protected_report, sizeof(gameoverlay_protected_report), 0
}
Кроме того, если соответствующий вызов OpenProcess к процессу оверлея возвращает ERROR_ACCESS_DENIED, то о пользователе высылается уведомление с id 3B.

Перебирание модулей
Модули процесса оверлея игр Steam тоже перебираются, в частности, ищутся vgui2_s.dll и gameoverlayui.dll. Для этих модулей выполняется несколько проверок, начиная с gameoverlayui.dll.

Если выполняется это условие: [gameoverlayui.dll+6C779] == 08BE55DC3CCCCB8????????C3CCCCCC, то шелл-код сканирует vtable по адресу, хранящемуся в байтах ????????. Если любой из этих элементов vtable находится за пределами исходного модуля gameoverlayui.dll или указывает на инструкцию int 3, то о пользователе сообщается на сервер с id уведомления 3B.

void gameoverlay::scan_vtable(HANDLE process_handle, char* buffer, MODULEENTRY32 module_entry)
{
char function_buffer[16

for (vtable_index = 0 vtable_index < 20 vtable_index += 4)
{
NtReadVirtualMemory(
process_handle,
*(int*)&buffer[vtable_index],
&function_buffer,
sizeof(function_buffer),
0

if (*(int*)&buffer[vtable_index] < module_entry.modBaseAddr ||
*(int*)&buffer[vtable_index] >= module_entry.modBaseAddr + module_entry.modBaseSize ||
function_buffer[0] == 0xCC ) // FUNCTION PADDING
{
gameoverlay_vtable_report.report_id = 0x3B
gameoverlay_vtable_report.vtable_index = vtable_index
gameoverlay_vtable_report.address = buffer[vtable_index
battleye::report(&gameoverlay_vtable_report, sizeof(gameoverlay_vtable_report), 0
}
}
}
Для модуля vgui2_s.dll тоже выполняется специфическая процедура проверки:

void vgui::scan()
{
if (!equals(vgui_buffer, «6A08B31FF561C8BD??????????FF96????????8BD????????8B1FF90»))
{
auto could_read = NtReadVirtualMemory(
process_handle, module_entry.modBaseAddr + 0x48338, vgui_buffer, 8, 0) >= 0

constexpr auto pattern_offset = 0x48378

// IF READ DID NOT FAIL AND PATTERN IS FOUND
if (could_read && equals(vgui_buffer, «6A46A06A26A»))
{
vgui_report.unknown_1 = 0
vgui_report.report_id = 0x3B
vgui_report.unknown_2 = 0
vgui_report.address = LODWORD(module_entry.modBaseAddr) + pattern_offset

// READ TARGET BUFFER INTO REPORT
NtReadVirtualMemory(
process_handle,
module_entry.modBaseAddr + pattern_offset,
vgui_report.buffer,
sizeof(vgui_report.buffer),
0

battleye::report(&vgui_report, sizeof(vgui_report), 0
}
}
else if (
// READ ADDRESS FROM CODE
NtReadVirtualMemory(process_handle, *(int*)&vgui_buffer[9], vgui_buffer, 4, 0) >= 0 &&
// READ POINTER TO CLASS
NtReadVirtualMemory(process_handle, *(int*)vgui_buffer, vgui_buffer, 4, 0) >= 0 &&
// READ POINTER TO VIRTUAL TABLE
NtReadVirtualMemory(process_handle, *(int*)vgui_buffer, vgui_buffer, sizeof(vgui_buffer), 0) >= 0)
{
for (vtable_index = 0 vtable_index < 984 vtable_index += 4 ) // 984/4 VTABLE ENTRY COUNT
{
NtReadVirtualMemory(process_handle, *(int*)&vgui_buffer[vtable_index], &vtable_entry, sizeof(vtable_entry), 0

if (*(int*)&vgui_buffer[vtable_index] < module_entry.modBaseAddr ||
*(int*)&vgui_buffer[vtable_index] >= module_entry.modBaseAddr + module_entry.modBaseSize ||
vtable_entry == 0xCC )
{
vgui_vtable_report.unknown = 0
vgui_vtable_report.report_id = 0x3B
vgui_vtable_report.vtable_index = vtable_index
vgui_vtable_report.address = *(int*)&vgui_buffer[vtable_index
battleye::report(&vgui_vtable_report, sizeof(vgui_vtable_report), 0
}
}
}
Данная процедура проверяет наличие изменений по смещению 48378, которое является расположением области кода:

push 04
push offset aCBuildslaveSte_4 ; «c:buildslavesteam_rel_client_win32″…
push offset aAssertionFaile_7 ; «Assertion Failed: IsValidIndex(elem)»
Затем процедура проверяет наличие очень специфического и кажущегося мусорным изменения:

push 04
push 00
push 02
push ??
Нам не удалось найти копию vgui2_s.dll, не соответствующую первой из двух вышеприведённых проверок, поэтому не можем узнать, какую vtable она проверяет.

Потоки оверлея игр Steam
Потоки в процессе оверлея игр Steam тоже перебираются:

void gameoverlay::check_thread(THREADENTRY32 thread_entry)
{
const auto tread_handle = OpenThread(THREAD_SUSPEND_RESUME|THREAD_GET_CONTEXT, 0, thread_entry.th32ThreadID
if (thread_handle)
{
suspend_count = ResumeThread(thread_handle
if (suspend_count > 0)
{
SuspendThread(thread_handle
gameoverlay_thread_report.unknown = 0
gameoverlay_thread_report.report_id = 0x3B
gameoverlay_thread_report.suspend_count = suspend_count
battleye::report(&gameoverlay_thread_report, sizeof(gameoverlay_thread_report), 0
}

if (GetThreadContext(thread_handle, &context) && context.Dr7)
{
gameoverlay_debug_report.unknown = 0
gameoverlay_debug_report.report_id = 0x3B
gameoverlay_debug_report.debug_register = context.Dr0
battleye::report(&gameoverlay_debug_report, sizeof(gameoverlay_debug_report), 0
}
}
}
LSASS
Адресное пространство памяти процесса Windows lsass.exe, также известного как процесс Local Security Authority, тоже перебирается и о всех аномалиях сообщается серверу, как и в случае двух предыдущих проверок:

if (equals(process_entry.executable_path, «lsass.exe»))
{
auto lsass_handle = OpenProcess(QueryInformation, 0, (unsigned int)process_entry.th32ProcessID
if (lsass_handle)
{
for (address = 0
NtQueryVirtualMemory(lsass_handle, address, 0, &lsass_memory_info, 0x30, &bytes_needed) >= 0
address = lsass_memory_info.base_address + lsass_memory_info.region_size)
{
if (lsass_memory_info.state == MEM_COMMIT
&& lsass_memory_info.type == MEM_PRIVATE
&& (lsass_memory_info.protect == PAGE_EXECUTE
|| lsass_memory_info.protect == PAGE_EXECUTE_READ
|| lsass_memory_info.protect == PAGE_EXECUTE_READWRITE))
{
// FOUND EXECUTABLE MEMORY OUTSIDE OF MODULES
lsass_report.unknown = 0
lsass_report.report_id = 0x42
lsass_report.base_address = lsass_memory_info.base_address
lsass_report.region_size = lsass_memory_info.region_size
lsass_report.memory_info =
lsass_memory_info.type | lsass_memory_info.protect | lsass_memory_info.state
battleye::report(&lsass_report, sizeof(lsass_report), 0
}
}
CloseHandle(lsass_handle
}
}
LSASS ранее использовался в эксплойтах для выполнения операций с памятью, так как любой процесс, которому нужно Интернет-подключение, должен предоставить доступ к нему LSASS. В настоящее время BattlEye справляется с этой проблемой, вручную очищая дескриптор процесса от операций чтения/записи, а затем подключая ReadProcessMemory/WriteProcessMemory, перенаправляя вызовы на свой драйвер BEDaisy. Далее BEDaisy решает, является ли операция с памятью законной. Если он считает, что операция законна, то он продолжает её, а в противном случае намеренно включает машине синий экран.

Различные уведомления
BattlEye собирает различную информацию и отправляет её серверу с id уведомления 3C. Эта информация состоит из следующих элементов:

  • Любое окно с флагом WS_EX_TOPMOST или его аналогами:
    • Текст окна (Unicode)
    • Имя класса окна (Unicode)
    • Window style
    • Window extended style
    • Прямоугольник окна
    • Путь к образу процесса-владельца
    • Размер образа процесса-владельца
  • Любой процесс с открытым игре дескриптором процесса (VM_WRITE|VM_READ)
    • Имя образа
    • Путь к образу
    • Размер образа
    • Доступ к дескриптору
  • Размер отдельных файлов игры:
    • ….ContentPaksTslGame-WindowsNoEditor_assets_world.pak
    • ….ContentPaksTslGame-WindowsNoEditor_ui.pak
    • ….ContentPaksTslGame-WindowsNoEditor_sound.pak

  • Содержимое отдельных файлов игры:
    • ….BLGameCookedContentScriptBLGame.u
  • Информация об обходе NtGetContextThread
    • Выполняются все инструкции перехода (E9), и адрес назначения записывается в лог

NoEye
В BattlEye реализована довольно ленивая проверка обнаружения публично доступного руткита для обхода этого античита под названием NoEye: система при помощи GetFileAttributesExA проверяет размер файла BE_DLL.dll, если эта библиотека найдена на диске.

void noeye::detect()
{
WIN32_FILE_ATTRIBUTE_DATA file_information
if (GetFileAttributesExA(«BE_DLL.dll», 0, &file_information))
{
noeye_report.unknown = 0
noeye_report.report_id = 0x3D
noeye_report.file_size = file_information.nFileSizeLow
battleye::report(&noeye_report, sizeof(noeye_report), 0
}
}
Наличие драйверов
Проверяется наличие устройств Beep и Null; в случае их наличия создаётся уведомление. В обычном состоянии эти два устройства не доступны в системе, и это может говорить о том, что кто-то вручную включил устройство. Такая техника называется driver device hijacking. Это делается для того, чтобы обеспечить обмен данными IOCTL с зловредным драйвером без необходимости отдельного объекта драйвера для этого драйвера.

void driver::check_beep()
{
auto handle = CreateFileA(«\.Beep», GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0
if (handle != INVALID_HANDLE_VALUE)
{
beep_report.unknown = 0
beep_report.report_id = 0x3E
battleye::report(&beep_report, sizeof(beep_report), 0
CloseHandle(handle
}
}
void driver::check_null()
{
auto handle = CreateFileA(«\.Null», GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0
if (handle != INVALID_HANDLE_VALUE)
{
null_report.unknown = 0
null_report.report_id = 0x3E
battleye::report(&null_report, sizeof(null_report), 0
CloseHandle(handle
}
}
Sleep delta
Кроме того, BattlEye может запрашивать у текущего потока одну секунду бездействия и измеряет разность количества циклов до и после бездействия (sleep):

void sleep::check_delta()
{
const auto tick_count = GetTickCount
Sleep(1000
const auto tick_delta = GetTickCount() — tick_count
if (tick_delta >= 1200)
{
sleep_report.unknown = 0
sleep_report.report_id = 0x45
sleep_report.delta = tick_delta
battleye::report(&sleep_report, sizeof(sleep_report), 0
}
}
7zip
В BattlEye добавлена очень ленивая проверка целостности, чтобы пользователи не могли загружать библиотеку 7zip в процессы игры и перезаписывать области. Это делалось пользователями, чтобы снизить серьёзность описанных ранее сканирований паттернов и обнаружения аномалий. В BattlEye просто решили добавить проверки целостности для этой конкретной библиотеки 7zip.

void module::check_7zip()
{
constexpr auto sz_7zipdll = «….PluginsZipUtilityThirdParty7zppdllWin647z.dll»
const auto module_handle = GetModuleHandleA(sz_7zipdll
if (module_handle && *(int*)(module_handle + 0x1000) != 0xFF1441C7)
{
sevenzip_report.unknown_1 = 0
sevenzip_report.report_id = 0x46
sevenzip_report.unknown_2 = 0
sevenzip_report.data1 = *(__int64*)(module_handle + 0x1000
sevenzip_report.data2 = *(__int64*)(module_handle + 0x1008
battleye::report(&sevenzip_report, sizeof(sevenzip_report), 0
}
}
Уровень аппаратных абстракций
BattlEye проверяет наличие динамически подключаемой библиотеки уровня аппаратных абстракций Windows (hal.dll), и сообщает серверу, загружена ли она внутри процесса игры.

void module::check_hal()
{
const auto module_handle = GetModuleHandleA(«hal.dll»
if (module_handle)
{
hal_report.unknown_1 = 0
hal_report.report_id = 0x46
hal_report.unknown_2 = 2
hal_report.data1 = *(__int64*)(module_handle + 0x1000
hal_report.data2 = *(__int64*)(module_handle + 0x1008
battleye::report(&hal_report, sizeof(hal_report), 0
}
}
Проверки образов
Также BattlEye проверяет различные образы, загруженные в процесс игры. Эти модули предположительно являются подписанными образами, которыми каким-то образом манипулируют, изменяя их поведение на зловредное, но подробнее мы ничего сказать о них не можем, только об их обнаружении:

nvToolsExt64_1
void module::check_nvtoolsext64_1
{
const auto module_handle = GetModuleHandleA(«nvToolsExt64_1.dll»
if (module_handle)
{
nvtools_report.unknown = 0
nvtools_report.report_id = 0x48
nvtools_report.module_id = 0x5A8
nvtools_report.size_of_image = (PE_HEADER*)(module_handle + (DOS_HEADER*)(module_handle)->e_lfanew))->SizeOfImage
battleye::report(&nvtools_report, sizeof(nvtools_report), 0
}
}
ws2detour_x96
void module::check_ws2detour_x96
{
const auto module_handle = GetModuleHandleA(«ws2detour_x96.dll»
if (module_handle)
{
ws2detour_report.unknown = 0
ws2detour_report.report_id = 0x48
ws2detour_report.module_id = 0x5B5
ws2detour_report.size_of_image = (PE_HEADER*)(module_handle + (DOS_HEADER*)(module_handle)->e_lfanew))->SizeOfImage
battleye::report(&ws2detour_report, sizeof(ws2detour_report), 0
}
}
networkdllx64
void module::check_networkdllx64
{
const auto module_handle = GetModuleHandleA(«networkdllx64.dll»
if (module_handle)
{
const auto dos_header = (DOS_HEADER*)module_handle
const auto pe_header = (PE_HEADER*)(module_handle + dos_header->e_lfanew
const auto size_of_image = pe_header->SizeOfImage

if (size_of_image < 0x200000 || size_of_image >= 0x400000)
{
if (pe_header->sections[DEBUG_DIRECTORY].size == 0x1B20)
{
networkdll64_report.unknown = 0
networkdll64_report.report_id = 0x48
networkdll64_report.module_id = 0x5B7
networkdll64_report.data = pe_header->TimeDatestamp
battleye::report(&networkdll64_report, sizeof(networkdll64_report), 0
}
}
else
{
networkdll64_report.unknown = 0
networkdll64_report.report_id = 0x48
networkdll64_report.module_id = 0x5B7
networkdll64_report.data = pe_header->sections[DEBUG_DIRECTORY].size
battleye::report(&networkdll64_report, sizeof(networkdll64_report), 0
}
}
}
nxdetours_64
void module::check_nxdetours_64
{
const auto module_handle = GetModuleHandleA(«nxdetours_64.dll»
if (module_handle)
{
nxdetours64_report.unknown = 0
nxdetours64_report.report_id = 0x48
nxdetours64_report.module_id = 0x5B8
nxdetours64_report.size_of_image = (PE_HEADER*)(module_handle + (DOS_HEADER*)(module_handle)->e_lfanew))->SizeOfImage
battleye::report(&nxdetours64_report, sizeof(nxdetours64_report), 0
}
}
nvcompiler
void module::check_nvcompiler
{
const auto module_handle = GetModuleHandleA(«nvcompiler.dll»
if (module_handle)
{
nvcompiler_report.unknown = 0
nvcompiler_report.report_id = 0x48
nvcompiler_report.module_id = 0x5BC
nvcompiler_report.data = *(int*)(module_handle + 0x1000
battleye::report(&nvcompiler_report, sizeof(nvcompiler_report), 0
}
}
wmp
void module::check_wmp
{
const auto module_handle = GetModuleHandleA(«wmp.dll»
if (module_handle)
{
wmp_report.unknown = 0
wmp_report.report_id = 0x48
wmp_report.module_id = 0x5BE
wmp_report.data = *(int*)(module_handle + 0x1000
battleye::report(&wmp_report, sizeof(wmp_report), 0
}
}
Идентификаторы перечисления модулей
Приведём для справки id перечисления для модулей:

enum module_id
{
nvtoolsext64 = 0x5A8,
ws2detour_x96 = 0x5B5,
networkdll64 = 0x5B7,
nxdetours_64 = 0x5B8,
nvcompiler = 0x5BC,
wmp = 0x5BE
Сканирование таблиц TCP
Шелл-код BattlEye выполняет поиск списка TCP-соединений всей системы (известного под названием «таблица TCP», TCP table) и сообщает, если пользователь подключен хотя бы к одному из IP-адресов Cloudflare-шлюза, принадлежащих немецкому веб-сайту pay-to-cheat под названием xera.ph. Этот механизм был добавлен в шелл-код для обнаружения пользователей, у которых при работе игры запущен launcher, благодаря чему они легко распознаются. Единственная проблема этого механизма заключается в том, что IP-адреса Cloudflare-шлюза позже могут сменить владельцев. и если их новый владелец будет распространять ПО, подключаемое к его серверам через определённый порт, то без всяких сомнений будут происходить ложноположительные срабатывания античита.

Пользователи провайдера услуг pay-to-cheat xera.ph уже долгое время сообщают о том, что их ловят, и разработчики никак не могут с этим справиться. Мы связались с разработчиками xera.ph, чтобы сообщить им об их глупом поведении, но они неправильно нас поняли и отправили нам бесплатную копию, не подумав, что мы сможем взломать и зарелизить её. Мы так не поступим, но, наверно, не стоит бесплатно отправлять проприетарные лицензионные двоичные файлы людям, занимающимся реверс-инжинирингом, и ожидать, что их не спиратят.

void network::scan_tcp_table
{
memset(local_port_buffer, 0, sizeof(local_port_buffer

for (iteration_index = 0 iteration_index < 500 ++iteration_index)
{
// GET NECESSARY SIZE OF TCP TABLE
auto table_size = 0
GetExtendedTcpTable(0, &table_size, false, AF_INET, TCP_TABLE_OWNER_MODULE_ALL, 0

// ALLOCATE BUFFER OF PROPER SIZE FOR TCP TABLE
auto allocated_ip_table = (MIB_TCPTABLE_OWNER_MODULE*)malloc(table_size

if (GetExtendedTcpTable(allocated_ip_table, &table_size, false, AF_INET, TCP_TABLE_OWNER_MODULE_ALL, 0) != NO_ERROR)
goto cleanup

for (entry_index = 0 entry_index < allocated_ip_table->dwNumEntries ++entry_index)
{
const auto ip_address_match_1 =
allocated_ip_table->table[entry_index].dwRemoteAddr == 0x656B1468 // 104.20.107.101

const auto ip_address_match_2 =
allocated_ip_table->table[entry_index].dwRemoteAddr == 0x656C1468 // 104.20.108.101

const auto port_match =
allocated_ip_table->table[entry_index].dwRemotePort == 20480

if ( (!ip_address_match_1 && !ip_address_match_2) || !port_match)
continue

for (port_index = 0
port_index < 10 &&
allocated_ip_table->table[entry_index].dwLocalPort !=
local_port_buffer[port_index
++port_index)
{
if (local_port_buffer[port_index])
continue

tcp_table_report.unknown = 0
tcp_table_report.report_id = 0x48
tcp_table_report.module_id = 0x5B9
tcp_table_report.data =
BYTE1(allocated_ip_table->table[entry_index].dwLocalPort) |
(LOBYTE(allocated_ip_table->table[entry_index.dwLocalPort) << 8

battleye::report(&tcp_table_report, sizeof(tcp_table_report), 0

local_port_buffer[port_index] = allocated_ip_table->table[entry_index].dwLocalPort
break

}
}

cleanup:
// FREE TABLE AND SLEEP
free(allocated_ip_table
Sleep(10
}
}
Типы уведомлений
Приведём для справки все известные типы уведомлений из шелл-кода:

enum BATTLEYE_REPORT_ID
{
MEMORY_GUARD = 0x21,
MEMORY_SUSPICIOUS = 0x2F,
WINDOW_TITLE = 0x33,
MEMORY = 0x35,
PROCESS_ANOMALY = 0x38,
DRIVER_BEEP_PRESENCE = 0x3E,
DRIVER_NULL_PRESENCE = 0x3F,
MISCELLANEOUS_ANOMALY = 0x3B,
PROCESS_SUSPICIOUS = 0x40,
LSASS_MEMORY = 0x42,
SLEEP_ANOMALY = 0x45,
MEMORY_MODULE_SPECIFIC = 0x46,
GENERIC_ANOMALY = 0x48,
MEMORY_MODULE_SPECIFIC2 = 0x5B,
}
Источник

I heart FeedBurner