Лишаем зрения античит систему многопользовательских игр

Встроенной системой слежения за процессом и окружающей его средой, с целью противодействия различным неавторизированным модификациям кода, уже никого не удивить: практически любой мало-мальски популярный многопользовательский игровой проект имеет нечто подобное. В этой статье мы проанализируем используемую разработчиками из Blizzard клиентскую защиту, а также реализуем один из эффективных способов ее обхода.

Warden (переводится с английского как смотритель, надзиратель) — именно так решили назвать защитную систему разработчики популярнейших в своих жанрах игр из Blizzard. Система, являясь фактически частью Battle.net, используется в таких проектах, как World of Warcraft, StarCraft II и Diablo 3. Только лишь по официальным данным за все время были забанены десятки тысяч аккаунтов Battle.net, и немалая часть при этом — заслуга Warden.

Безмолвный смотритель

Для начала, пожалуй, стоит выяснить, что собой представляет Warden. Система состоит из двух частей: серверной и клиентской, и, само собой, мы будем иметь дело только с клиентской частью. Как уже было сказано ранее, Warden не является неотъемлемой частью игрового кода. Код клиентской части подгружается динамически с Battle.net в виде образов, отдаленно напоминающих по своей структуре Portable Executable, которые затем отображаются по случайным адресам в адресном пространстве игрового процесса. Стоит также отметить, что большая часть кода клиентской части Warden обфусцирована и может изменяться от одной игровой сессии к другой.

Warden представляет собой пассивный механизм защиты, и все, чем занимается клиентская часть Warden, — это сбор информации, которая впоследствии отправляется серверной части. В целом примерный алгоритм работы клиентской части Warden выглядит следующим образом:

1. Получение списка относительных адресов для сканирования.
2. Считывание необходимого количества байт по каждому из адресов.
3. Расчет хешей.
4. Компоновка пакета с хешами и отправка его на сервер.

Процедура повторяется с некоторой периодичностью несколько раз в минуту. Если серверная часть обнаруживает несоответствие хешей эталонным значениям, считается, что используются запрещенные модификации кода. Каких-либо незамедлительных действий при этом не предпринимается — аккаунт просто помечается как нарушающий правила, а о том, что ты «попался» можно будет узнать лишь через некоторое время, когда учетная запись уже будет заблокирована. Целиком аккаунт Battle.net (который может содержать множество прикрепленных лицензий) при этом не блокируется — только учетная запись игры.

Другие статьи в выпуске:

Хакер #187. Обходим Blizzard Warden

• Содержание выпуска
• Подписка на «Хакер»-60%

Против системы

Нейтрализовать Warden, просто отключив его либо заблокировав его работу, не удастся: система устроена таким образом, что серверная часть в любом случае должна получать от клиентской ответные пакеты, которые, в свою очередь, должны содержать информацию о сканировании. Следовательно, выход только один — не попадаться. Добиться этого можно как минимум тремя способами:

1. Обходить стороной заведомо опасные адреса при внесении модификаций в код.
2. Использовать косвенное внедрение, перехватывая один из методов DirectX — Device.EndScene().
3. Прятать все совершенные модификации на лету (при сканировании).

Первый вариант будет работать до поры до времени и по большому счету обходом как таковым не является. Второй вариант (перехват EndScene()) действительно неплохо работает, функция вызывается после завершения построения каждого выводимого на экран кадра и перехватывается, например вполне легальными программами видеозахвата, что не дает Warden возможности однозначно трактовать изменения в коде функции как запрещенные модификации. Тем не менее вариант больше годится для ботов и успешно ими эксплуатируется на протяжении уже нескольких лет. Третий вариант идеально подходит для статичных модификаций (как, например, включение отрисовки всей карты в Star Craft — maphack), кроме того, его реализация сама по себе интереснее и технологичнее. Именно последний вариант подробно и рассмотрим далее.

Очевидно, что для сокрытия произведенных модификаций необходимо внедриться в сканирующий код Warden. Как известно, этот код не присутствует в процессе со старта, к тому же при загрузке получает случайный адрес. На первый раз его можно обнаружить при помощи отладчика, просто установив breakpoint на чтение любого из сканируемых адресов (от какого-либо старого, давно детектируемого хака). Например, для последнего (на момент написания статьи) билда World of Warcraft, установив breakpoint по относительному базе основного образа адресу 0x0045A6F0, мы попадаем в следующий участок кода:

masm
push  esi
push  edi
cld
mov   edx, dword ptr ss:[esp+14h]
mov   esi, dword ptr ss:[esp+10h]
mov   eax, dword ptr ss:[esp+0Ch]
mov   ecx, edx
mov   edi, eax
shr   ecx, 2
je short 
; Здесь данные попадают во временный буфер, с которого будет рассчитываться хеш.
; Достаточно подставлять вместо измененных байт оригинальные
rep   movs dword ptr es:[edi], dword ptr ds:[esi]
mov   cl, 3
and   ecx, edx
je short 
rep   movs byte ptr es:[edi], byte ptr ds:[esi]
pop   edi
pop   esi
ret

Опытным путем было установлено, что обнаруженный код не подвергается полиморфным изменениям, в отличие от всего остального модуля, к тому же изменялся он за последние годы лишь однажды, что делает его идеальной мишенью для внедрения. Но так как этот код — часть загружаемого динамически модуля, то необходимо будет также перехватить момент его появления в процессе, чтобы внести изменения до первого исполнения. В случае с WoW загрузчик является частью кода игры и находится прямо в Wow.exe (для 32-битной версии), его можно найти, перелопатив километры листингов в дизассемблере, или пойти более хитрым путем. Память под загружаемые образы модулей Warden выделяется функциейVirtualAlloc(), лог вызовов, с указанием места, откуда был произведен вызов, будет содержать адрес, принадлежащий загрузчику.

c++
void VA_hook_(DWORD dwCallAddr, DWORD dwMemBlock, DWORD dwSize)
{
    if ( dwMemBlock && dwSize > 0x2000 )
    {
        Logger::OutLog("Allocated block:%.8x - %.8x, called from:%.8x\r\n", dwMemBlock, dwMemBlock+dwSize, dwCallAddr );
    }
}

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

c++
Scanner::TPattern WardenPattern ("\x56\x57\xFC\x8B\x54\x24\x14\x8B\x74\x24\x10\x8B\x44\x24\x0C\x8B\xCA\x8B\xF8\xC1\xE9\x02\x74\x02\xF3\xA5", "x26");
DWORD WardenProc = (DWORD) Scanner::ScanMem( &WardenPattern );
if ( WardenProc )
{
    Logger::OutLog("Warden::Scan proc:0x%.8X\r\n", WardenProc);
}
else 
    Logger::OutLog("Warden::Scan proc not found\r\n");

Таким образом мы определим точное текущее местоположение необходимого нам кода Warden, а лог вызовов VirtualAlloc() позволит определить, откуда именно была запрошена память под этот код, указав тем самым на загрузчик модулей Warden. Проанализировав в дизассемблере код загрузчика, можно найти подходящее место для перехвата. Для этого нужно найти подходящий момент, когда все секции образа, полученного из Сети, будут успешно отображены в АП процесса, после этого можно будет внедрять перехват, модифицирующий код Warden. Подходящим участком может быть вызов VirtualProtect(), устанавливающий финальные права доступа к секциям:

masm
lea   ecx, [ebp+flOldProtect]
push  ecx ; lpflOldProtect
push  dword ptr [esi+8] ; flNewProtect
push  eax ; dwSize
push  ebx ; lpAddress
call  ds:VirtualProtect
test  byte ptr [esi+8], 0F0h
jz short loc_A5BE9C
push  [ebp+dwSize]    ; dwSize
push  ebx ; lpBaseAddress
call  ds:GetCurrentProcess
push  eax ; hProcess
call  ds:FlushInstructionCache

Код функции-трамплина, переход на которую установлен вместо call ds:VirtualProtect, может выглядеть следующим образом:

c++
// Вызывается для каждой секции
__declspec(naked) void WardenLoader_hook( LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect )
{
    __asm 
    {
        push ebp
        mov ebp, esp
        pushad
    }
    if ( flNewProtect==PAGE_EXECUTE_READ ) // Для секции, содержащей исполнимый код
        WardenModulePatch(lpAddress, dwSize); // Патчим код Warden
    __asm
    {
        popad
        pop ebp
        jmp dword ptr[VirtualProtect]
    }
}

c++
// Инициализируем паттерн
// Первый параметр — данные для сравнения, второй — шаблон сравнения
Scanner::TPattern SamplePattern ("\x56\x57\xFC\x00\x00\x90", "x3?2x1");

/*
    Этот паттерн соответствует данным, у которых первые три байта совпадают с 0x56, 0x57, 0xFC,
    затем идут два произвольных байта, а последний совпадает с 0x90
*/

// Поиск по заданному паттерну в ограниченной области, с началом pMemBase и размером dwSize
DWORD dwProc = (DWORD) Scanner::FindPattern( pMemBase, dwSize, &SamplePattern );

Патчер

Для того чтобы была возможность скрывать свои действия от глаз Warden, необходимо запоминать абсолютно все производимые в памяти процесса изменения и иметь доступ к оригинальным данным, существовавшим до внесения изменений. Любые изменения (перехваты, подмены и прочее) должны производиться одним и тем же средством, которое должно гарантировать выполнение изложенных требований:

c++
/* 
    pAddr — указатель на место производимой модификации
    pData — данные для замены
    dwDataSize — размер данных
*/
BOOL Patcher::MakePatch( PBYTE pAddr, PBYTE pData, DWORD dwDataSize )
{
    BOOL fRes = false;
    DWORD dwOldp;
    if ( VirtualProtect( pAddr, dwDataSize, PAGE_EXECUTE_READWRITE, &dwOldp) )
    {
        // Запоминаем оригинальные байты
        pPatchStruc  = &Patches[dwPatches]; // Последний элемент
        pPatchStruc->addr = dwAddr;
        pPatchStruc->len = dwSize;
        memcpy( pPatchStruc->org , (PVOID) dwAddr, dwSize );
        // Записываем новые
        memcpy( pAddr, pData, dwDataSize );
        dwPatches++
        fRes = true;
    }
    return fRes;
}

Список структур, содержащий информацию по всем совершенным в процессе изменениям, может принадлежать объекту с глобальной областью видимости. Модифицирование кода теперь может производиться примерно следующим образом:

c++
bool PatchVirutalProtect()
{
    bool bRetval = false;
    PBYTE bCode = (PBYTE) "\xE8\x90\x90\x90\x90\x90"; // call rel32
    DWORD pProc = (DWORD) GetProcAddress( GetModuleHandleA( "KernelBase.DLL"), "VirtualProtect" );
    *((PDWORD)(bCode+1)) = (DWORD)&VP_hook - ((DWORD)pProc+5);
    if ( Patcher::Instance()->MakePatch( (PBYTE)pProc, bCode, 5 ) ) 
    {
        Logger::OutLog( "VirtualProtect patched at: %x\r\n", pProc );
        bRetval = true;
    }
    else Logger::OutLog( "VirtualProtect patch failed\r\n" );
    return bRetval;
}

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

Невидящее око Warden’а

Теперь, когда есть вся необходимая информация и инструменты, осталось подменить сканирующую процедуру Warden своей, которая вместо модифицированных данных будет подставлять оригинальные. Хеши в таком случае будут идентичны тем, что хранятся на сервере, и изменения кода останутся незамеченными.

Чтобы в поле зрения Warden не попало ни одного измененного байта, при каждом вызове сканирования необходимо искать пересечение множеств сканируемых адресов с адресами пропатченных данных. Так как патчи, скорее всего, не будут идти один за другим (это не имеет смысла) — будет максимум одно пересечение для одного скана и данные можно будет брать из структуры, связанной с каким-то одним конкретным патчем. Все возможные варианты пересечений сводятся к одному двойному условию: либо адрес начала множества сканируемых байт входит во множество адресов патча, либо наоборот. Таким образом, мы должны перебирать все патчи, проверяя заданное условие:

c++
// Попадают ли сканируемые адреса под какой-либо патч?
for ( unsigned int i=0; i< dwPatches; i++) // перебираем все патчи
    if ( (PatchList[i].addr - dwAddr < dwSize) || ( dwAddr - PatchList[i].addr < PatchList[i].len ) ) // Находим пересечение
    {
        pCurrentPatch = &(PatchList[i]);
        break;
    }

Получив сопряженную с текущим сканированием структуру с информацией о патче, подменить данные не составит труда:

c++
if (!pCurrentPatch) 
{
    // Сканируется непропатченная область — копируем напрямую
    memcpy(pOutBuff, (PVOID)dwAddr, dwSize);
}
else
{
    // Побайтовая обработка
    for ( unsigned int i=0; i< dwSize; i++) 
    {
        unsigned int delta = dwAddr+i - pCurrentPatch->addr;
        byte* pCurrent;
        // Был ли байт по этому адресу пропатчен?
        if( delta < pCurrentPatch->len ) 
            pCurrent = pCurrentPatch->org + delta;
        else
            pCurrent = (PBYTE)(dwAddr+i);

        pOutBuff[i] = *pCurrent; 
    }
}

Используя приведенный код вместо оригинальной процедуры сканирования, мы можем контролировать активность Warden, не давая ему возможности обнаружить любые внесенные в код изменения, даже в том случае, если Warden попытается проверить на целостность самого себя.

Proof of concept

В качестве демонстрации работоспособности обхода с извлечением какой-то практической пользы было принято решение произвести модификацию кода World of Warcraft по относительному смещению 0x008C9A3E, которое проверяется сканером Warden. Процедура, соответствующая этому смещению, ответственна за проверку прав на исполнение Lua-скрипта (многие из функций WoW API заблокированы для пользователя и могут быть использованы только родным пользовательским интерфейсом). Участок кода в области этого смещения выглядит следующим образом:

masm
mov   ebp, esp
mov   edx,dword ptr ss:[ebp+8]
mov   eax,dword ptr ds:[17A5B10]
xor   ecx,ecx
push  esi
cmp   dword ptr ds:[15FBAA8],ecx
je short 01309A84
cmp   edx, 22

Само смещение соответствует условному переходу после сравнения глобальной переменной, содержащей идентификатор уровня доступа для текущего контекста, с нолем (ноль соответствует самым высоким правам). Заменив условный переход безусловным, получаем возможность использовать любые функции WoW API, создавая сложные и «умные» скрипты, автоматизирующие многие игровые действия (самый примитивный пример использования: забиндить всю ротацию спеллов на одну кнопку, с проверкой кулдаунов и так далее, что сделать изначально невозможно). Упрощенный код установки патча выглядит примерно так:

c++
PBYTE   bCode = (PBYTE) "\xEB"; // JMP SHORT
Scanner::TPattern Pattern( "\x33\xC9\x56\x39\x0D\xFF\xFF\xFF\xFF\x74\x44\x83\xFA\x22", "x5?4x5");

DWORD dwProc = (DWORD) Scanner::ScanMem( &Pattern );
if ( dwProc )
{
    DWORD dwProcChangeOffset = dwProc+9;
    if ( Patcher::Instance()->MakePatch( (PBYTE)dwProcChangeOffset, bCode, 1 );
}

После установки патча становятся доступны прямо из макросов «защищенные» функции WoW API, а в логе активности Warden мы можем наблюдать предотвращенные попытки просканировать пропатченную область. Убедиться в этом ты можешь, скомпилировав и опробовав прилагаемые к статье исходники.

c++
void VP_hook_internal( DWORD dwCallAddr, DWORD dwMemBlock, DWORD dwSize, DWORD flNewProtect)
{
    // Вызов был произведен из battle.net.dll
    if (dwCallAddr - WardenLoaderHack::dwBNetBase < WardenLoaderHack::dwBNetImageSize)
    {
        // Секция кода
        if ( dwMemBlock && flNewProtect==PAGE_EXECUTE_READ )
        {
            MEMORY_BASIC_INFORMATION Mem;
            // Ищем начало блока памяти
            if  ( VirtualQuery( (PVOID) dwMemBlock, &Mem, sizeof (MEMORY_BASIC_INFORMATION)) )
            {
                // Первые четыре байта — сигнатура модуля Warden
                if ( *(PDWORD)Mem.AllocationBase == '2LLB' )
                {
                    Logger::OutLog("Warden image found at:%.8X, code section:%.8X\r\n", Mem.AllocationBase, dwMemBlock);
                    // Патчим код Warden
                    WardenModulePatch(dwMemBlock, dwSize);
}   }   }   }   }

Полная свобода действий

Возможность безнаказанно вносить любые изменения в игровой клиент открывает широчайшие перспективы для дальнейших исследований. На самом деле в играх Blizzard можно сотворить абсолютно все, что только можно себе представить или захотеть. Об одних лишь возможностях разблокированных скриптов Lua в WoW можно было бы написать отдельную статью. Ведь даже простые скрипты могут избавить игрока от рутинных действий или снизить зависимость от реакции и внимательности, позволив уделять чуть больше времени другим вещам. При этом возможности свободных модификаций клиента не ограничиваются простой разблокировкой тех или иных возможностей. В общем, дерзай!