[REQUEST] DLL Auto-Inject Source

Ask for Help on Using the Language With Memory Hacking Software

Moderators: g3nuin3, SpeedWing, WhiteHat, mezzo

[REQUEST] DLL Auto-Inject Source

Postby ravenflyer » Tue Mar 10, 2009 9:37 am

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.
I'm playing Risk Your Life for while :)
User avatar
ravenflyer
Been Around
 
Posts: 270
Joined: Tue Mar 18, 2008 4:51 am

Postby spunge » Tue Mar 10, 2009 10:39 am

Either modify the IAT, or create a proxy DLL.
spunge
NULL
 
Posts: 121
Joined: Sun Jul 27, 2008 4:58 am
Location: VEH callback

Postby CodeMaster.Rapture » Tue Mar 10, 2009 11:29 am

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;
}
CodeMaster.Rapture
Hackleberry Fin
 
Posts: 20
Joined: Sun Mar 16, 2008 2:15 pm

Postby ravenflyer » Wed Mar 11, 2009 2:56 am

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.
I'm playing Risk Your Life for while :)
User avatar
ravenflyer
Been Around
 
Posts: 270
Joined: Tue Mar 18, 2008 4:51 am

Postby JB Gzn » Wed Mar 11, 2009 3:10 am

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.
Image
ImageImage

famous wrote:What's worth the price is always worth the fight


famous wrote:Every second counts cause there's no second try
User avatar
JB Gzn
Pro++
 
Posts: 1985
Joined: Sun Jan 27, 2008 7:56 pm
Location: Unknown, please use a pointer.

Postby ravenflyer » Wed Mar 11, 2009 3:21 am

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
I'm playing Risk Your Life for while :)
User avatar
ravenflyer
Been Around
 
Posts: 270
Joined: Tue Mar 18, 2008 4:51 am


Return to Help

Who is online

Users browsing this forum: No registered users and 2 guests

cron