[REQUEST] DLL Auto-Inject Source

Something I've used in the past and I got from Azorbix's Tatnium DirectX base (external C++ App):

Kod:

/***********************************************\
*  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;
}

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

Kod:

#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; http://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

Kod:

#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