HelpAdicionar NX Chams

// Creditos pela DIPEngine WE11ngton, HackerFail modificou para auto on e Swag postou umas
// funçoes em D3D

#include <windows.h> 
#include <d3d9.h> 
#include <d3dx9.h> 
#include "Enderecos.h"

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

#pragma message("Créditos a WE11ngton , HackerFail e Swag!!")

DWORD retDIPEngine = (DIPEngine + 0x8); 

void Command(CONST CHAR *szCommand)
{
	__asm
	{
		PUSHAD
		PUSH szCommand
		MOV EAX, 0x4860B0
		CALL EAX
		ADD ESP, 0x4
		POPAD
	}
}

__declspec( naked ) HRESULT WINAPI DIPMidfunction( ) 
{ 

static LPDIRECT3DDEVICE9 pDevice; 
static INT BaseVertexIndex; 
static UINT MinVertexIndex, NumVertices, startIndex, primCount; 

__asm 
{ 
MOV ECX, DWORD PTR DS:[EAX] 
MOV EDX, DWORD PTR DS:[ECX + 0x148] 
MOV DWORD PTR DS:[pDevice], EAX; 
MOV ECX, DWORD PTR DS:[EBP + 0x18] 
MOV DWORD PTR DS:[BaseVertexIndex], ECX 
MOV ECX, DWORD PTR DS:[EBP + 0x8] 
MOV DWORD PTR DS:[MinVertexIndex], ECX 
MOV ECX, DWORD PTR DS:[EBP + 0x10] 
MOV DWORD PTR DS:[NumVertices], ECX 
MOV ECX, DWORD PTR DS:[EBP + 0xC] 
MOV DWORD PTR DS:[startIndex], ECX 
MOV ECX, DWORD PTR DS:[EBP + 0x14] 
MOV DWORD PTR DS:[primCount], ECX 
PUSHAD 
}

pDevice->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE ); // WallHacker
memcpy((VOID *)EspName1, (VOID *)(PBYTE)"\x90\x90", 2); // ESPNames 1
memcpy((VOID *)EspName2, (VOID *)(PBYTE)"\x90\x90", 2); // ESPNames 2
memcpy((VOID *)NoRecoil, (VOID *)(PBYTE)"\x90\x90\x90\x90", 4); // No Recoil
memcpy((VOID *)SuperBullets, "\x90\x90\x90", 3); // Super Bullets
Command("SkelModelStencil 1");// NX Chams
pDevice->SetRenderState(D3DRS_FOGENABLE, FALSE); // No Fog
pDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME ); // Player Wireframe
pDevice->SetRenderState(D3DRS_LIGHTING, FALSE); // Full Bright

__asm 
{ 
POPAD 
JMP retDIPEngine 
} 
} 

void *DetourCreate( BYTE *src, const BYTE *dst, const int len ) 
{ 
BYTE *jmp = ( BYTE * )malloc( len + 5 ); 
DWORD dwBack; 

VirtualProtect( src, len, PAGE_EXECUTE_READWRITE, &dwBack ); 
memcpy( jmp, src, len ); 
jmp += len; 
jmp[0] = 0xE9; 
*( DWORD * )( jmp + 1 ) = ( DWORD )( src + len - jmp ) - 5; 
src[0] = 0xE9; 
*( DWORD * )( src + 1 ) = ( DWORD )( dst - src ) - 5; 
for( int i = 5; i < len; i++ ) 
src[i] = 0x90; 
VirtualProtect( src, len, dwBack, &dwBack ); 
return ( jmp - len ); 
} 

VOID Hook( VOID ) 
{ 
while( TRUE ) { 
if( *(BYTE *)GameStatus == 1 ) { 

DetourCreate( (PBYTE)DIPEngine, (PBYTE)DIPMidfunction, 8 );
} 
else 
memcpy( (VOID *)DIPEngine, (CONST VOID *)(PBYTE)"\x8B\x08\x8B\x91\x48\x01\x00\x00", 8 ); 

Sleep(100); 
} 
} 

BOOL CheckModules( VOID ) 
{ 
if( GetModuleHandleA("d3d9.dll") != NULL 
&& GetModuleHandleA("CShell.dll") != NULL 
&& GetModuleHandleA("ClientFX.fxd") != NULL ) 
return TRUE; 

return FALSE; 
} 

DWORD WINAPI StartRoutine( LPVOID ) 
{ 
while( !CheckModules() ) 
Sleep(100); 

Hook(); 

return 0; 
}

BOOL WINAPI DllMain ( HINSTANCE hDll, DWORD dwReason, LPVOID lpReserved )
{
if ( dwReason == DLL_PROCESS_ATTACH )
{
MessageBoxA(NULL, "Creditos: WE11ngton, HackerFail and Swag", "Creditos", MB_OK);
CreateThread(NULL, NULL, &StartRoutine, NULL, NULL, NULL);
}

return 1;
}

#define VC_EXTRALEAN
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <d3dx9.h>

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

#define DeviceGame			0x9138F8
#define ConsoleUnwrapped	0x4860B0

VOID WINAPIV vRunConsoleCommand(CONST CHAR *szCommand)
{
	__asm
	{
		PUSHAD
		PUSH szCommand
		MOV EAX, ConsoleUnwrapped
		CALL EAX
		ADD ESP, 0x4
		POPAD
	}
}

BOOL GameReady2Hook(VOID)
{
	if(GetModuleHandle("d3d9.dll") != NULL && GetModuleHandle("CShell.dll") != NULL && GetModuleHandle("ClientFX.fxd") != NULL)
		return TRUE;

	return FALSE;
}

DWORD PegarVTable(INT valor)
{
	DWORD *Device = ***(DWORD ****)DeviceGame;

	if(Device == NULL)
		return 0;

	return Device[valor];
}

#define Detour_Type_0xE9  1
#define Detour_Type_0xB8  2
#define Detour_Type_0x68  3

unsigned int iPointerssfghs***retg[5] = {0xE9, 0xB8, 0xE0FF, 0x68, 0xC3};

DWORD CreateDetour(DWORD dwThread, DWORD dwAdress, DWORD dwType, DWORD dwSize)
{
	DWORD dwDetour, dwProtect, i;
	if(dwAdress && dwThread && dwSize >= dwSize)
	{
		dwDetour = (DWORD)VirtualAlloc(0, dwSize + dwSize, 0x1000, 0x40);
		if(dwDetour && VirtualProtect((VOID *)dwAdress, dwSize, 0x40, &dwProtect))
		{
			for(i = 0; i < dwSize; i++) 
			{
				*(BYTE *)(dwDetour + i) = *(BYTE *)(dwAdress + i);
			}

			switch(dwType)
			{
			    case Detour_Type_0xE9:
				{
				    *(BYTE *)(dwDetour + dwSize + 0) = iPointerssfghs***retg[0];
				    *(DWORD *)(dwDetour + dwSize + 1) = (dwAdress - dwDetour - dwSize);
	    		    *(BYTE *)(dwAdress + 0) = iPointerssfghs***retg[0];
				    *(DWORD *)(dwAdress + 1) = (dwThread - dwAdress - dwSize);
				}
				break;

				case Detour_Type_0xB8:
				{
				    *(BYTE *)(dwDetour + dwSize + 0) = iPointerssfghs***retg[1];
				    *(DWORD *)(dwDetour + dwSize + 1) = (dwAdress + dwSize);
				    *(WORD *)(dwDetour + dwSize + 5) = iPointerssfghs***retg[2]; 
				    *(BYTE *)(dwAdress + 0) = iPointerssfghs***retg[1];            
				    *(DWORD *)(dwAdress + 1) = (dwThread);
				    *(WORD *)(dwAdress + 5) = iPointerssfghs***retg[2]; 
				}
				break;

				case Detour_Type_0x68:
				{
				    *(BYTE *)(dwDetour + dwSize + 0) = iPointerssfghs***retg[3];
				    *(DWORD *)(dwDetour + dwSize + 1) = (dwAdress + dwSize);
				    *(WORD *)(dwDetour + dwSize + 5) = iPointerssfghs***retg[4]; 
				    *(BYTE *)(dwAdress + 0) = iPointerssfghs***retg[3];            
				    *(DWORD *)(dwAdress + 1) = (dwThread);
				    *(WORD *)(dwAdress + 5) = iPointerssfghs***retg[4]; 
				}
				break;
			}

			VirtualProtect((VOID *)dwAdress, dwSize, dwProtect, &dwProtect);
			VirtualProtect((VOID *)dwDetour, dwSize + dwSize, 0x20, &dwProtect);
	    	return dwDetour;
		}
	}

	Sleep(10);
	return(0);
}

typedef HRESULT(WINAPI *tPresent)(LPDIRECT3DDEVICE9 pDevice, CONST RECT *a, CONST RECT *b, HWND c, CONST RGNDATA *d);
tPresent oPresent;

HRESULT WINAPI hkPresent(LPDIRECT3DDEVICE9 pDevice, CONST RECT *a, CONST RECT *b, HWND c, CONST RGNDATA *d)
{
	__asm PUSHAD;
	
	if(*(long*)0x3781F62C == 1) {
		memcpy((void*)0x3725C519, (void*)"\x90\x90", 2);
		memcpy((void*)0x3725C59F, (void*)"\x90\x90", 2);
		vRunConsoleCommand("SkelModelStencil 1");
	}
	__asm POPAD;
	return oPresent(pDevice, a, b, c, d);
}

DWORD WINAPI dwHook(LPVOID)
{
	while(!GameReady2Hook())
		Sleep(500);

	oPresent = (tPresent)CreateDetour((DWORD)&hkPresent, (DWORD)PegarVTable(17), Detour_Type_0xE9, 5);

	return NULL;
}

BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
{
	DisableThreadLibraryCalls(hModule);

	if(dwReason == DLL_PROCESS_ATTACH)
	{
		CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)dwHook, NULL, NULL, NULL);
	}

	return TRUE;
}