D3D Logger

/************************************************************************/
/*                                                                      */
/*              Programm:   Stride, ReturnAddress Logger            */
/*                                                                      */
/*      Entwickler: agrippa1994                     */
/*                                                                      */
/************************************************************************/

#pragma comment(lib,"d3dx9.lib")
#pragma comment(lib,"detours.lib")

#include <windows.h>
#include <detours.h>
#include <d3dx9.h>
#include <intrin.h>
#include <vector>
#include <iostream>

using namespace std;

#pragma intrinsic(_ReturnAddress)

typedef HRESULT (WINAPI *_DrawIndexedPrimitive) (LPDIRECT3DDEVICE9,D3DPRIMITIVETYPE,INT,UINT,UINT,UINT,UINT);

//////////////////////////////////////////////////////////////////////////
//                  globale Variablen       //
//////////////////////////////////////////////////////////////////////////
bool            g_LoggerOn;
bool            g_FirstRun;
bool            g_DrawMode;
int         g_Index;
int         g_Stride;
int         g_primCount;
_DrawIndexedPrimitive   g_oDrawIndexedPrimitive;
LPDIRECT3DTEXTURE9  g_Green;
LPDIRECT3DTEXTURE9  g_Red;
vector<DWORD>       g_Addresses;

//////////////////////////////////////////////////////////////////////////
//                  Funktionsprototypen     //
//////////////////////////////////////////////////////////////////////////

bool    WINAPI      DllMain(HINSTANCE hInstance,DWORD dwReason,void* Reserved);
void            InitHack();
void            InitHooks();

HRESULT WINAPI      hDrawIndexedPrimitive(LPDIRECT3DDEVICE9 pDevice,D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);

bool            DataCompare(const BYTE* pData, const BYTE* bMask, const char* szMask);
DWORD           FindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask);
HRESULT         GenerateTexture(IDirect3DDevice9 *pD3Ddev, IDirect3DTexture9 **ppD3Dtex, DWORD colour32);
void            OpenConsole();

//////////////////////////////////////////////////////////////////////////
//                  Funktionsdefinitionen       //
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
//                  Initialisierungen       //
//////////////////////////////////////////////////////////////////////////
bool __stdcall DllMain(HINSTANCE hInstance,DWORD dwReason,void* Reserved)
{
    if(dwReason == DLL_PROCESS_ATTACH)
    {
        CreateThread(0,0,(LPTHREAD_START_ROUTINE)InitHack,0,0,0);
        return true;
    }
    else if(dwReason == DLL_PROCESS_DETACH)
    {
        g_Red->Release();
        g_Green->Release();

        FreeConsole();

        DetourRemove((PBYTE) g_oDrawIndexedPrimitive, (PBYTE) hDrawIndexedPrimitive);
        return true;
    }
    return false;
}
void InitHack()
{
    OpenConsole();
    printf("Der Logger wurde gestartet!\n");
    printf("Steuerung:\n");
    printf("INSERT:\tWireframe / Texturen\n");
    printf("DEL:\tAktivieren der leuchtenden Texturen / Chams\n");
    printf("END:\tDeaktivieren der leuchtenden Texturen / Chams\n");
    printf("ADD:\tErhöhen des ReturnAddresses Index\n");
    printf("SUB:\tVerkleinern des ReturnAddresses Index\n");
    printf("MULT:\tErhöhen der Stride\n");
    printf("DIV:\tVerkleinern der Stride\n");
    printf("NUM7:\tVerkleinern des PrimCounts\n");
    printf("NUM9:\tErhöhen des PrimCounts\n");
    printf("HOME:\tDeaktivieren des Loggers, vorbereiten auf sicheres Entladen\n");
    printf("--------------------------------------------------------------------------\n\n");

    g_DrawMode = false;

    g_Addresses.clear();
    g_Index = 0;

    g_FirstRun = true;
    g_LoggerOn = false;

    g_primCount = -1;
    g_Stride = -1;

    InitHooks();


    while(true)
    {
        if(GetAsyncKeyState(VK_INSERT))
            g_DrawMode = !g_DrawMode;
        if(GetAsyncKeyState(VK_DELETE))
            g_LoggerOn = true;
        if(GetAsyncKeyState(VK_END))
            g_LoggerOn = false;
        if(GetAsyncKeyState(VK_ADD))
        {
            if(g_Addresses.size() > (g_Index+1))
                g_Index++;
            printf("Stride: %d PrimCount: %d ReturnAdress: 0x%X, Index: %d\n",g_Stride,g_primCount,g_Addresses[g_Index],g_Index);
        }
        if(GetAsyncKeyState(VK_SUBTRACT))
        {
            if(g_Index > 0)
                g_Index --;
            printf("Stride: %d PrimCount: %d ReturnAdress: 0x%X, Index: %d\n",g_Stride,g_primCount,g_Addresses[g_Index],g_Index);
        }
        if(GetAsyncKeyState(VK_MULTIPLY))
        {
            g_Stride ++;
            printf("Stride: %d PrimCount: %d ReturnAdress: 0x%X, Index: %d\n",g_Stride,g_primCount,g_Addresses[g_Index],g_Index);
        }
        if(GetAsyncKeyState(VK_DIVIDE))
        {
            g_Stride --;
            printf("Stride: %d PrimCount: %d ReturnAdress: 0x%X, Index: %d\n",g_Stride,g_primCount,g_Addresses[g_Index],g_Index);
        }
        if(GetAsyncKeyState(VK_NUMPAD7))
        {
            g_primCount --;
            printf("Stride: %d PrimCount: %d ReturnAdress: 0x%X, Index: %d\n",g_Stride,g_primCount,g_Addresses[g_Index],g_Index);
        }
        if(GetAsyncKeyState(VK_NUMPAD9))
        {
            g_primCount ++;
            printf("Stride: %d PrimCount: %d ReturnAdress: 0x%X, Index: %d\n",g_Stride,g_primCount,g_Addresses[g_Index],g_Index);
        }
        if(GetAsyncKeyState(VK_HOME))
        {
            printf("Die DLL kann nun sicher entladen werden!");
            return;
        }
        Sleep(100);
    }
}
void InitHooks()
{
    HMODULE hModule = NULL;

    while((hModule = GetModuleHandleA("d3d9.dll")) == NULL)
        Sleep(100);

    // Initialisieren des DIP Hooks
    DWORD *VTable = 0;
    DWORD Pattern = FindPattern((DWORD)hModule, 0x128000, (PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86", "xx????xx????xx");
    memcpy(&VTable, (void*)(Pattern+2), 4);

    g_oDrawIndexedPrimitive = (_DrawIndexedPrimitive) DetourFunction((PBYTE)VTable[82],(PBYTE)hDrawIndexedPrimitive);
}
//////////////////////////////////////////////////////////////////////////
//              HOOK                    //
//////////////////////////////////////////////////////////////////////////

HRESULT WINAPI hDrawIndexedPrimitive(LPDIRECT3DDEVICE9 pDevice,D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
    if(g_FirstRun)
    {
        GenerateTexture(pDevice,&g_Green,D3DCOLOR_ARGB(255,0,255,0));
        GenerateTexture(pDevice,&g_Red,D3DCOLOR_ARGB(255,255,0,0));
        g_FirstRun = false;
    }


    DWORD Ret = (DWORD)_ReturnAddress();

    if(g_Addresses.size() > (g_Index) && g_LoggerOn)
    {
        UINT Stride, Offset;
        IDirect3DVertexBuffer9 *Vertex;

        if(pDevice->GetStreamSource(0,&Vertex,&Offset,&Stride) == D3D_OK)
            Vertex->Release();

        if(Ret == g_Addresses[g_Index] && (Stride == g_Stride || g_Stride == -1) && (g_primCount == -1 || primCount == g_primCount))
        {
            pDevice->SetRenderState( D3DRS_ZENABLE, false );

            // Objekt hinter Mauer
            if(g_DrawMode)
                pDevice->SetTexture(0,g_Green);
            else
                pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

            pDevice->SetRenderState( D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_CONTINUOUS );
            pDevice->DrawIndexedPrimitive(Type,BaseVertexIndex,MinVertexIndex,NumVertices,startIndex,primCount);

            // Objekt vor Mauer
            if(g_DrawMode)
                pDevice->SetTexture(0,g_Red);
            pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
            pDevice->SetRenderState( D3DRS_ZENABLE, true );
            pDevice->DrawIndexedPrimitive(Type, BaseVertexIndex, MinVertexIndex, NumVertices,startIndex, primCount );
        }
    }

    for(int i=0;i<g_Addresses.size();i++)
        if(g_Addresses[i] == Ret)
            return g_oDrawIndexedPrimitive(pDevice,Type,BaseVertexIndex,MinVertexIndex,NumVertices,startIndex,primCount);

    g_Addresses.push_back(Ret);
    printf("Adresse 0x%X geloggt!\n",Ret);

    return g_oDrawIndexedPrimitive(pDevice,Type,BaseVertexIndex,MinVertexIndex,NumVertices,startIndex,primCount);
}
//////////////////////////////////////////////////////////////////////////
//              UTILS                                                   //
//////////////////////////////////////////////////////////////////////////

bool DataCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
    for(;*szMask;++szMask,++pData,++bMask)
        if(*szMask=='x' && *pData!=*bMask )
            return false;
    return (*szMask) == NULL;
}
DWORD FindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask)
{
    for(DWORD i=0; i < dwLen; i++)
        if(DataCompare((BYTE*)(dwAddress+i),bMask,szMask))
            return (DWORD)(dwAddress+i);
    return 0;
}

HRESULT GenerateTexture(IDirect3DDevice9 *pD3Ddev, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
{
    if( FAILED(pD3Ddev->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED,
        ppD3Dtex, NULL)) )
        return E_FAIL;
    WORD colour16 = ((WORD)((colour32>>28)&0xF)<<12)
        |(WORD)(((colour32>>20)&0xF)<<8)
        |(WORD)(((colour32>>12)&0xF)<<4)
        |(WORD)(((colour32>>4)&0xF)<<0);
    D3DLOCKED_RECT d3dlr;
    (*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
    WORD *pDst16 = (WORD*)d3dlr.pBits;
    for(int xy=0; xy < 8*8; xy++)
        *pDst16++ = colour16;
    (*ppD3Dtex)->UnlockRect(0);
    return S_OK;
}

void OpenConsole()
{
    if(AllocConsole())
    {
        freopen("CONOUT$","w",stdout);
        SetConsoleTitleA("Logger");
    }
}