Page 1 of 1

[REQUEST] DLL Auto-Inject Source

PostPosted: Tue Mar 10, 2009 9:37 am
by ravenflyer
As the tittle says, someone have the souce of one DLL thats auto inject the code on the process when it is opened? Like in Wolfteam?

Thanks.

PostPosted: Tue Mar 10, 2009 10:39 am
by spunge
Either modify the IAT, or create a proxy DLL.

PostPosted: Tue Mar 10, 2009 11:29 am
by CodeMaster.Rapture
Something I've used in the past and I got from Azorbix's Tatnium DirectX base (external C++ App):

Code: Select all
/***********************************************\
*   Program : Tatnium Injector               *
*   Author : Matthew L (Azorbix)            *
*   Date : December 22nd, 2003               *
*   Credits:   Y0DA, OGC guys, RetarT, Mstr   *
*            LanceVorgin, P47R!CK, VisPrfn   *
\***********************************************/
//you will need VC++ .net or VC++6.0 w/ service packs

#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>
#include <winbase.h>
#include "forcelib\forcelib.h"
#define WIN32_LEAN_AND_MEAN

#define APP_EXE "target_application.exe" //change this!!!

bool GetProcessOf(char exename[], PROCESSENTRY32 *process)
{
   HANDLE handle ;
   process->dwSize = sizeof(PROCESSENTRY32);
   handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

   if(Process32First(handle, process))
   {
      do
      {
         if(strcmpi(process->szExeFile, exename) == 0)
         {
            CloseHandle(handle);
            return true;
         }
      }while(Process32Next(handle, process));
   }

   CloseHandle(handle);
   return false;
}

bool GetThreadOf(DWORD ProcessID, THREADENTRY32 *thread)
{
   HANDLE handle;
   thread->dwSize = sizeof(THREADENTRY32);
   handle = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);

   if(Thread32First(handle, thread))
   {
      do
      {
         if(thread->th32OwnerProcessID == ProcessID)
         {
            CloseHandle(handle);
            return true;
         }
      }while(Thread32Next(handle, thread));
   }

   CloseHandle(handle);
   return false;
}

bool fileExists(const char filename[])
{
   WIN32_FIND_DATA finddata;
   HANDLE handle = FindFirstFile(filename,&finddata);
   return (handle!=INVALID_HANDLE_VALUE);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{   
   PROCESSENTRY32 pe32;
   THREADENTRY32 te32;

   HANDLE handle = CreateMutex(NULL, true, "ttn5loader");
   if(GetLastError() != ERROR_SUCCESS)
   {
      MessageBox(0, "Process is already running", "Tatnium Warning", MB_ICONWARNING);
      return 0;
   }

   char dllname[MAX_PATH];
   GetModuleFileName(0, dllname, MAX_PATH);
   dllname[strlen(dllname)-3] = 0;
   strcat(dllname, "dll");

   if(!fileExists(dllname))
   {
      MessageBox(0, "Could not find dll", "Tatnium Error", MB_ICONERROR);
      return 0;
   }

   MessageBox(0, "\tTatnium Injector\n Press \'END\' to exit without injection ", "Tatnium Injector", 0);
   
   while(!GetProcessOf(APP_EXE, &pe32))
   {
      if(GetAsyncKeyState(VK_END))
         return 0;
      Sleep(10);
   }
   
   while(!GetThreadOf(pe32.th32ProcessID, &te32))
   {
      Sleep(2);
   }

   PROCESS_INFORMATION PI;
   PI.dwProcessId = pe32.th32ProcessID;
   PI.dwThreadId = te32.th32ThreadID;
   PI.hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pe32.th32ProcessID);

   if(!ForceLibrary(dllname, &PI))
   {
      TerminateProcess(PI.hProcess, 0);
      MessageBox(0, "Could not inject dll", "Tatnium Error", MB_ICONERROR);
   }

   CloseHandle(PI.hProcess);

   return 0;
}

PostPosted: Wed Mar 11, 2009 2:56 am
by ravenflyer
you dont have the souce there with an "hack" or somthing like this to me?
Because I rly want to avoid errors =/

im having problem with forcelib.h
I dont know so much about C++... just the basic.. and I have no idea to aht I should to write there.

Thanks.

PostPosted: Wed Mar 11, 2009 3:10 am
by JB Gzn
u should just add this to the dll.
if your missing something then u miss the header or so.\
u can find those on the internet.

PostPosted: Wed Mar 11, 2009 3:21 am
by ravenflyer
hmm... Look at the DLL is a very very old wolfteam dll source that CompMaster give to me. I always use this... works fine for me and what I need to know is where I put the "Auto-Inject" source on the Hack DLL Source?

The Hack DLL Source:
Main.cpp

Code: Select all
#include <windows.h>
#include <fstream>
#include <string>
using namespace std;

#include "main.h"
#include "forcelib.h"

#define APP_EXE "client.exe" //change this!!!

//Globals
int haxvals[] = {3020,3002,9004,9006,6004,3010,9003,9006,7003,3008,9004,9006,7005,8501,9006,5007};

bool weapAmmo = false;
//bool weapHax = false;
bool weapPoints = false;
//bool speedJumpHax = false;
//bool wallHax = false;

//HANDLE initHP;
HANDLE initWP;
//HANDLE initWeaponHax;
HANDLE initWeaponAmmo;
//HANDLE initWeapons;
//HANDLE initJumpSpeedHax;
//HANDLE initWallHax;

HANDLE weapAmmohWnd;
HANDLE WPhWnd;
//HANDLE weapHaxhWnd;
//HANDLE speedJumphWnd;
//HANDLE wallHaxhWnd;

//default used F keys for WT - F2,F4,F5,F8

/*
  Hotkeys:
  F1 - WP Hax
  F3 - Weapon Hax
  F6 - Infinite Ammo/No Reload Hax
  F7 - Weapons Hax
  F9 - HP Hax
  F12 - Speed/Jump Hax
*/

bool GetProcessOf(char exename[], PROCESSENTRY32 *process)
{
   HANDLE handle ;
   process->dwSize = sizeof(PROCESSENTRY32);
   handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

   if(Process32First(handle, process))
   {
      do
      {
         if(strcmpi(process->szExeFile, exename) == 0)
         {
            CloseHandle(handle);
            return true;
         }
      }while(Process32Next(handle, process));
   }

   CloseHandle(handle);
   return false;
}

bool GetThreadOf(DWORD ProcessID, THREADENTRY32 *thread)
{
   HANDLE handle;
   thread->dwSize = sizeof(THREADENTRY32);
   handle = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);

   if(Thread32First(handle, thread))
   {
      do
      {
         if(thread->th32OwnerProcessID == ProcessID)
         {
            CloseHandle(handle);
            return true;
         }
      }while(Thread32Next(handle, thread));
   }

   CloseHandle(handle);
   return false;
}
 
bool fileExists(const char filename[])
{
   WIN32_FIND_DATA finddata;
   HANDLE handle = FindFirstFile(filename,&finddata);
   return (handle!=INVALID_HANDLE_VALUE);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{   
   PROCESSENTRY32 pe32;
   THREADENTRY32 te32;

   HANDLE handle = CreateMutex(NULL, true, "ttn5loader");
   if(GetLastError() != ERROR_SUCCESS)
   {
      MessageBox(0, "Process is already running", "Tatnium Warning", MB_ICONWARNING);
      return 0;
   }

   char dllname[MAX_PATH];
   GetModuleFileName(0, dllname, MAX_PATH);
   dllname[strlen(dllname)-3] = 0;
   strcat(dllname, "dll");

   if(!fileExists(dllname))
   {
      MessageBox(0, "Could not find dll", "Tatnium Error", MB_ICONERROR);
      return 0;
   }

   MessageBox(0, "\tTatnium Injector\n Press \'END\' to exit without injection ", "Tatnium Injector", 0);
   
   while(!GetProcessOf(APP_EXE, &pe32))
   {
      if(GetAsyncKeyState(VK_END))
         return 0;
      Sleep(10);
   }
   
   while(!GetThreadOf(pe32.th32ProcessID, &te32))
   {
      Sleep(2);
   }

   PROCESS_INFORMATION PI;
   PI.dwProcessId = pe32.th32ProcessID;
   PI.dwThreadId = te32.th32ThreadID;
   PI.hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pe32.th32ProcessID);

   if(!ForceLibrary(dllname, &PI))
   {
      TerminateProcess(PI.hProcess, 0);
      MessageBox(0, "Could not inject dll", "Tatnium Error", MB_ICONERROR);


      //initHP = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)HP, NULL, NULL, NULL);
      initWP = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)WP, NULL, NULL, NULL);
      //initWeaponHax = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)WeaponHax, NULL, NULL, NULL);
      initWeaponAmmo = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)WeaponAmmo, NULL, NULL, NULL);
      //initWeapons = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Weapons, NULL, NULL, NULL);
      //initJumpSpeedHax = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)JumpSpeedHax, NULL, NULL, NULL);
      //initWallHax = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)WallHax, NULL, NULL, NULL);

      WPhWnd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WPThread, NULL, NULL, NULL);
      //weapHaxhWnd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WeaponHaxThread, NULL, NULL, NULL);
      weapAmmohWnd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WeaponAmmoThread, NULL, NULL, NULL);
      //speedJumphWnd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SpeedJumpHaxThread, NULL, NULL, NULL);
      //wallHaxhWnd = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WallHaxThread, NULL, NULL, NULL);
      return true;
   }
   else if(dwReason == DLL_PROCESS_DETACH)
   {
      CloseHandle(WPhWnd);
      //CloseHandle(weapHaxhWnd);
      CloseHandle(weapAmmohWnd);
      //CloseHandle(speedJumphWnd);
      //CloseHandle(wallHaxhWnd);

      //CloseHandle(initHP);
      CloseHandle(initWP);
      //CloseHandle(initWeaponHax);
      CloseHandle(initWeaponAmmo);
      //CloseHandle(initWeapons);
      //CloseHandle(initJumpSpeedHax);
      //CloseHandle(initWallHax);
      CloseHandle(PI.hProcess);
   }
    return 0;
}

void WeaponAmmoThread(void *param)
{
   while(true)
   {
      while (weapAmmo == false) Sleep(100);

      DWORD OldProt;

      while (weapAmmo == true)
      {
      //Weapon 0 Main
      int *offset = (int*)0x0073AD48;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 1148731950;
      VirtualProtect(offset, 4, OldProt, &OldProt);
/*
      //Weapon 0 Secondary
      offset = (int*)0x34286D38;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 0 Special (left)
      offset = (int*)0x34287A68;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 0 Special (right)
      offset = (int*)0x34288100;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Main
      offset = (int*)0x34288E70;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Secondary
      offset = (int*)0x342887D8;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Special (left)
      offset = (int*)0x34289508;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Special (right)
      offset = (int*)0x34289BA0;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Main
      offset = (int*)0x3428A910;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Secondary
      offset = (int*)0x3428A278;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Special (left)
      offset = (int*)0x3428AFA8;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Special (right)
      offset = (int*)0x3428B640;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Main
      offset = (int*)0x3428C3B0;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Secondary
      offset = (int*)0x3428BD18;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Special (left)
      offset = (int*)0x3428CA48;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Special (right)
      offset = (int*)0x3428D0E0;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 9999;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //No Reload
      DWORD dwPtr = (*(PDWORD)0x342861DC) + 1620;  // [342861DC]+1620
      *(PDWORD)dwPtr = 99;
*/
      Sleep(100);
      }
   }
}

/*void WeaponHaxThread(void *param)
{
   while(true)
   {
      while (weapHax == false) Sleep(100);

      DWORD OldProt;

      while (weapHax == true)
      {
      //Weapon Speed
      int *offset = (int*)0x3427C624;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 6242432;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Recoil
      offset = (int*)0x3427C628;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 0;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Spray
      offset = (int*)0x3427C64C;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 1;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Rocket Launcher/Sniper Zoom Hack
      offset = (int*)0x3427C6E4;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 0;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Crosshair
      offset = (int*)0x3427C66C;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 1073741823;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //1 Shell to Reload Shotgun
      offset = (int*)0x3427C668;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 0;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      Sleep(100);
      }
   }
}*/

void WPThread(void *param)
{
   while(true)
   {
      while (weapPoints == false) Sleep(100);

      DWORD OldProt;

      while (weapPoints == true)
      {
      //WP
      int *offset = (int*)0x0073AD48;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 1153731950;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      Sleep(100);
      }
   }
}

/*void SpeedJumpHaxThread(void *param)
{
   while(true)
   {
      while (speedJumpHax == false) Sleep(100);

      while (speedJumpHax == true)
      {
      //[[[[[340022f0]+16]+a4]+0]+24]+b8 - Speed
      //[[[[[340022f0]+16]+a4]+0]+24]+a4 - Jump

      DWORD dwPtr = (*(PDWORD)0x340022F0) + 16;  // [340022F0]+16
      dwPtr = (*(PDWORD)dwPtr) + 0xA4; // +A4
      dwPtr = (*(PDWORD)dwPtr) + 0; // +0
      dwPtr = (*(PDWORD)dwPtr) + 24; // +24
      
      DWORD dwSpeed = (*(PDWORD)dwPtr) + 0xB8; // +B8
      DWORD dwJump = (*(PDWORD)dwPtr) + 0xA4; // +A4

      *(PDWORD)dwSpeed = 1143078912; //5x Wolf
      *(PDWORD)dwJump = 1149255680; //1.5x Wolf

      Sleep(100);
      }
   }
}
*/

/*void WallHaxThread(void *param)
{
   while(true)
   {
      while (wallHax == false) Sleep(100);

      while (wallHax == true)
      {
      //Wallhack - [3427C354]+740

      DWORD dwPtr = (*(PFLOAT)0x3427C354) + 740;  // [3427C354]+740

      int *offset = (*int)dwPtr;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 0x540BE3FF;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      *(PFLOAT)dwPtr = 9200;

      Sleep(250);
      }
   }
}*/

/*DWORD WINAPI HP(LPVOID lpParam) //F2
{
   DWORD OldProt;

      while(true)
      {
       while(!(GetAsyncKeyState(0x71))) Sleep(100);

      int *offset = (int*)0x0073AD48;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = 1148731950;
      VirtualProtect(offset, 4, OldProt, &OldProt);

      Sleep(100);
      }
   return 0;
}*/

/*DWORD WINAPI WallHax(LPVOID lpParam) //F11
{
      while(true)
      {
       while(!(GetAsyncKeyState(0x7A))) Sleep(100);

      wallHax = !wallHax;
      Sleep(1000);
      }
   return 0;
}*/

DWORD WINAPI WP(LPVOID lpParam) //F1
{
      while(true)
      {
       while(!(GetAsyncKeyState(0x70))) Sleep(100);

      if (weapPoints == true) return 0;

      weapPoints = !weapPoints;
      Sleep(1000);
      }
   return 0;
}

/*DWORD WINAPI WeaponHax(LPVOID lpParam) //F3
{
      while(true)
      {
       while(!(GetAsyncKeyState(0x72))) Sleep(100);

      //if (weapHax == true) return 0;

      weapHax = !weapHax;
      Sleep(1000);
      }
   return 0;
}*/

DWORD WINAPI WeaponAmmo(LPVOID lpParam) //F2
{
      while(true)
      {
       while(!(GetAsyncKeyState(0x71))) Sleep(100);

      if (weapAmmo == true) return 0;

      weapAmmo = !weapAmmo;
      Sleep(1000);
      }
   return 0;
}

/*DWORD WINAPI Weapons(LPVOID lpParam) //F7
{
   ReadWeapons();

   DWORD OldProt;

      while(true)
      {
       while(!(GetAsyncKeyState(0x76))) Sleep(100);

      //Weapon 0 Main
      int *offset = (int*)0x34257C1C;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[0];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 0 Secondary
      offset = (int*)0x34257C28;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[1];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 0 Special (left)
      offset = (int*)0x34257C34;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[2];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 0 Special (right)
      offset = (int*)0x34257C3C;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[3];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Main
      offset = (int*)0x34257C80;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[4];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Secondary
      offset = (int*)0x34257C8C;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[5];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Special (left)
      offset = (int*)0x34257C98;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[6];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 1 Special (right)
      offset = (int*)0x34257CA0;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[7];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Main
      offset = (int*)0x34257CE4;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[8];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Secondary
      offset = (int*)0x34257CF0;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[9];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Special (left)
      offset = (int*)0x34257CFC;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[10];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 2 Special (right)
      offset = (int*)0x34257D04;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[11];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Main
      offset = (int*)0x34257D48;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[12];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Secondary
      offset = (int*)0x34257D54;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[13];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Special (left)
      offset = (int*)0x34257D60;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[14];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      //Weapon 3 Special (right)
      offset = (int*)0x34257D68;
      VirtualProtect(offset, 4, PAGE_EXECUTE_READWRITE, &OldProt);
      *offset = haxvals[15];
      VirtualProtect(offset, 4, OldProt, &OldProt);

      Sleep(250);
      }
   return 0;
}

/*DWORD WINAPI JumpSpeedHax(LPVOID lpParam) //F12
{
   while(true)
      {
       while(!(GetAsyncKeyState(0x7B))) Sleep(100);

      speedJumpHax = !speedJumpHax;
      Sleep(1000);
   }
}*/

void ReadWeapons()
{
   int linenum = 0;
   string line;
   ifstream myfile;
   myfile.open("wtwep.txt");

   if (myfile.is_open())
   {
      while (!myfile.eof())
      {
      getline (myfile, line);

      if (atoi(line.c_str()) != 0)
      {
         haxvals[linenum] = atoi(line.c_str());
      }
      
      linenum+=1;
      }
      myfile.close();
   }
}


Main.h

Code: Select all
#include <windows.h>
#include <stdio.h>
#include <winbase.h>
#define WIN32_LEAN_AND_MEAN

#ifndef _MAIN_H
#define _MAIN_H

void WeaponAmmoThread(void *param);
//void WeaponHaxThread(void *param);
void WPThread(void *param);
//void SpeedJumpHaxThread(void *param);

/*void WallHaxThread(void *param);
DWORD WINAPI WallHax(LPVOID lpParam);*/

//DWORD WINAPI HP(LPVOID lpParam);
DWORD WINAPI WP(LPVOID lpParam);
//DWORD WINAPI WeaponHax(LPVOID lpParam);
DWORD WINAPI WeaponAmmo(LPVOID lpParam);
//DWORD WINAPI Weapons(LPVOID lpParam);
//DWORD WINAPI JumpSpeedHax(LPVOID lpParam);

void ReadWeapons();


#endif


PS: I uploaded both, the Hack DLL and the Tatnium Source

http://rapidshare.com/files/207679213/TatniumInjectionAndWTOldDLL.rar