AIM BULLET Update base+offset

 /*  
 RELEASE : 20150813 (base dan ofset up to date)  
 UPDATE AUTO AIM BULLET  
 base source : jazzy http://www.nyit-nyit.net/threads/source-pb-hard-hack.173340/  
 dan google  
 image : http://i.imgur.com/d1DKANO.jpg  
 edit by Me, gosicks AKA hero  
 http://www.nyit-nyit.net/members/gosicks.76305/  
 website : www.heroich.net  
 contact : gosicks@ymail.com  
 #### WARNING ####  
 hanya untuk pembelajaran   
 jika ingin mencoba gunakan Injektor yg UNDETECT !!!  
 banned bukan tanggung jawab kami...  
 */  
 #include <Windows.h>  
 #include <d3d9.h>  
 #include <d3dx9.h>  
 #pragma comment(lib, "d3d9.lib")  
 #pragma comment(lib, "d3dx9.lib")  
 //#include "..\..\..\..\A_POINTBLANK\log.h"  
 //#include "..\..\..\..\A_POINTBLANK\XOR.h"  
 using namespace std;  
 #define heroichnet /*www.heroich.net*/XorStr<0xD5,16,0x52F2DF46>("\xA2\xA1\xA0\xF6\xB1\xBF\xA9\xB3\xB4\xBD\xB7\xCE\x8F\x87\x97"+0x52F2DF46).s  
 ////////////////////////////////////////////////////////////////////////// BASE  
 #define BASECHARA 0x0BCB6C8  
 #define BaseHealth 0x0BCB694  
 ////////////////////////////////////////////////////////////////////////// DECLAR  
 DWORD dwi3scene,dwSetEnd,keyboard;  
 bool BulletEnable= false;  
 float fX = 0x0A, fY = 0x01, fZ = 0x0A;  
 ////////////////////////////////////////////////////////////////////////// FUNGSI  
 #define CT(function) CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)(function), 0, NULL, NULL)  
 void MakeJMP(BYTE *pAddress, DWORD dwJumpTo, DWORD dwLen)  
 {  
      DWORD dwOldProtect, dwBkup, dwRelAddr;  
      // give the paged memory read/write permissions  
      VirtualProtect(pAddress, dwLen, PAGE_EXECUTE_READWRITE, &dwOldProtect);  
      // calculate the distance between our address and our target location  
      // and subtract the 5bytes, which is the size of the jmp  
      // (0xE9 0xAA 0xBB 0xCC 0xDD) = 5 bytes  
      dwRelAddr = (DWORD) (dwJumpTo - (DWORD) pAddress) - 5;  
      // overwrite the byte at pAddress with the jmp opcode (0xE9)  
      *pAddress = 0xE9;  
      // overwrite the next 4 bytes (which is the size of a DWORD)  
      // with the dwRelAddr  
      *((DWORD *)(pAddress + 0x1)) = dwRelAddr;  
      // overwrite the remaining bytes with the NOP opcode (0x90)  
      // NOP opcode = No OPeration  
      for(DWORD x = 0x5; x < dwLen; x++) *(pAddress + x) = 0x90;  
      // restore the paged memory permissions saved in dwOldProtect  
      VirtualProtect(pAddress, dwLen, dwOldProtect, &dwBkup);  
      return;  
 }  
 ////////////////////////////////////////////////////////////////////////// CLASS  
 class CBone  
 {  
 public:  
      D3DXMATRIX BoneMatrix;  
 };  
 class CBonesContext  
 {  
 public:  
      char Unk[216];  
      CBone* BoneData;  
 };  
 class CGameBase  
 {  
 public:  
      char Unk[1368];  
      CBonesContext* Bones;  
 };  
 struct CTeam  
 {  
      BYTE iTeam;  
 };  
 class CDeadStat  
 {  
 public:  
      BYTE Dead; //0x0000   
 };//Size=0x0001  
 struct CPlayers  
 {  
      float yaw;  
      float pitch;  
      D3DXVECTOR3 pos;  
      char unkno8[0x60];  
 };  
 struct CHealth  
 {  
      float CurHP;  
 };  
 ////////////////////////////////////////////////////////////////////////// SET END HOOK  
 _declspec(naked)  
      void i3CollideeEnd()  
 {  
      _asm  
      {  
           cmp [BulletEnable], 0;  
           je Skip;  
           mov eax, [esp+4];  
           mov [eax], edx;  
           mov edx, [fX];  
           mov [eax+0], edx;  
           mov edx, [fY];  
           mov [eax+4],edx;  
           mov edx, [fZ];  
           mov [eax+8], edx;  
           mov edx, [ecx+8];  
 Skip:  
           jmp Original;  
           nop;  
 Original:  
           mov eax, [esp+4];  
           fld dword ptr [eax];  
           fstp dword ptr [ecx+0x18];  
           fld dword ptr [eax+0x04];  
           fstp dword ptr [ecx+0x1C];  
           fld dword ptr [eax+0x08];  
           fstp dword ptr [ecx+0x20];  
           fld dword ptr [ecx+0x18];  
           fsub dword ptr [ecx+0x0C];  
           fstp dword ptr [ecx+0x24];  
           fld dword ptr [ecx+0x1C];  
           fsub dword ptr [ecx+0x10];  
           fstp dword ptr [ecx+0x28];  
           fld dword ptr [ecx+0x20];  
           fsub dword ptr [ecx+0x14];  
           fstp dword ptr [ecx+0x2C];  
           ret 4;  
      }  
 }  
 int GetTeam(int MyT)  
 {  
      __try   
      {  
           if(MyT == 0 || MyT == 2 || MyT == 4 || MyT == 6 || MyT == 8 || MyT == 10|| MyT == 12|| MyT == 14)  
                return 1;  
      }__except(EXCEPTION_EXECUTE_HANDLER)  
      {  
           return 0;  
      }  
      __try  
      {  
           if(MyT == 1 || MyT == 3 || MyT == 5 || MyT == 7 || MyT == 9 || MyT == 11|| MyT == 13|| MyT == 15)  
                return 2;  
           return 0;  
      }__except(EXCEPTION_EXECUTE_HANDLER)  
      {  
           return 0;  
      }  
 }  
 BYTE GetPlayerIsDead (int idxplayer)  
 {  
      DWORD temp = *(PDWORD)(BASECHARA);  
      BYTE mati = *(PDWORD)((temp + 0x2C54C)+idxplayer);  
      return mati;  
 }  
 int GetMyCharaIndex()  
 {  
      DWORD cPlayer = *(PDWORD)(BASECHARA);  
      CTeam *MyTeam = (CTeam*)(cPlayer + 0x299F4);  
      return MyTeam->iTeam;  
 }  
 float CalcDistance(D3DXVECTOR3 VecA, D3DXVECTOR3 VecB)  
 {  
      return sqrt(((VecA.x - VecB.x) * (VecA.x - VecB.x)) + ((VecA.y - VecB.y) * (VecA.y - VecB.y)) + ((VecA.z - VecB.z) * (VecA.z - VecB.z)));  
 }  
 D3DXVECTOR3 GetUserVector(DWORD i)  
 {  
      DWORD dwBasePlayer = *(PDWORD)(BASECHARA);  
      CPlayers *pPlayer = (CPlayers*)((*(PDWORD)(dwBasePlayer + 0x4 * i + 0x27B24)) + 0x64);  
      return pPlayer->pos;  
 }  
 bool GetUserBone(D3DXVECTOR3 &Out, int BoneIdx, int Idx)  
 {  
      DWORD dwGameBase = *(PDWORD)BaseHealth;  
      if(dwGameBase)  
      {  
           CGameBase* GameBase = (CGameBase*)(*(PDWORD)(dwGameBase + 0x14 + (0x4 * Idx)));  
           if(Idx > -1)  
           {  
                if(GameBase && GameBase->Bones)  
                {  
                     Out.x = GameBase->Bones->BoneData[ BoneIdx ].BoneMatrix._41;  
                     Out.y = GameBase->Bones->BoneData[ BoneIdx ].BoneMatrix._42;  
                     Out.z = GameBase->Bones->BoneData[ BoneIdx ].BoneMatrix._43;  
                     return true;  
                }  
           }  
      }  
      return false;  
 }  
 ////////////////////////////////////////////////////////////////////////// cek indeks player terdekat  
 int AutomaticTarget()  
 {  
      int Result = -1;  
      float NearDistance = 1000.0f;  
      int MyTeam = GetTeam(GetMyCharaIndex());  
      for(int i = 0; i<16; i++)  
      {  
           int TargetTeam = GetTeam(i);  
           if(TargetTeam == MyTeam)continue;  
           if(TargetTeam == 0)continue;  
           if(GetPlayerIsDead(i)== 1)continue; //Cek player hidup / mati  
           if(CalcDistance(GetUserVector(GetMyCharaIndex()), GetUserVector(i)) < NearDistance)  
           {  
                NearDistance = CalcDistance(GetUserVector(GetMyCharaIndex()), GetUserVector(i));  
                Result = i;  
           }  
      }  
      return Result;  
 }  
 void GetPosAimBullet ()  
 {  
      fX = NULL;  
      fY = NULL;  
      fZ = NULL;  
      int AimSlot = AutomaticTarget(); // cek target  
      if(AimSlot != -1)  
      {  
           D3DXVECTOR3 OnWorld, OnScreen;  
           int BoneIndexSelector = 7;//kepala  
           if(GetUserBone(OnWorld, 7, AimSlot))  
           {  
                //BulletEnable = true;  
                fX = OnWorld.x;  
                fY = OnWorld.y + 0.1f;//di plus biar pas kepala   
                fZ = OnWorld.z;  
           }//else BulletEnable = false;  
      }//else BulletEnable = false;  
 }  
 ////////////////////////////////////////////////////////////////////////// CEK dalam permainan atau di loby  
 BYTE GetIngame ()  
 {  
      DWORD tIngame = *(PDWORD)BASECHARA;  
      BYTE ingame = *(PBYTE)(tIngame + 0xA80);  
      return ingame;  
 }  
 void HackON ()  
 {  
      while (1)  
      {  
           __try   
           {  
                if (GetIngame () == 3)  
                {  
                     BulletEnable = true;  
                     GetPosAimBullet ();  
                }  
                else  
                {  
                      BulletEnable = false;  
                }  
           }  
           __except(EXCEPTION_EXECUTE_HANDLER)  
           {  
           }  
           Sleep(20);  
      }  
 }  
 void StartPointerHack ()  
 {  
      do   
      {  
           dwi3scene = (DWORD)GetModuleHandle("i3SceneDx.dll");  
           Sleep(1000);  
      } while (!dwi3scene);  
      dwSetEnd = (DWORD)GetProcAddress((HINSTANCE)dwi3scene,"?SetEnd@i3CollideeLine@@QAEXPATVEC3D@@@Z");  
      MakeJMP((PBYTE)dwSetEnd,(DWORD)i3CollideeEnd,5);  
      //i3CollideeLine::i3CollideeLine  
      HackON ();  
 }  
 BOOL WINAPI DllMain(HMODULE hDll, DWORD dwReason, LPVOID lpReserved)  
 {  
      if(dwReason == DLL_PROCESS_ATTACH)  
      {  
           DisableThreadLibraryCalls(hDll);  
           //CT(bypassxc);  
           ShellExecute(NULL,"open",heroichnet,NULL,NULL,SW_SHOWNORMAL);  
           CT(StartPointerHack);  
      }  
      return TRUE;  
 }  

[Delphi] Volume Serial HWID HDD

 function FindVolumeSerial(const Drive : PChar) : string;  
 var  
 fileSystemName, volumeName: array[0..99] of char;  
 fileSystemFlags, serialNo, maxFilenameLength: DWORD;  
 imp:String;  
 begin  
 Result:='';  
 GetVolumeInformation(Drive, volumeName,SizeOf(volumeName), @serialNo,maxFilenameLength, fileSystemFlags,fileSystemName, SizeOf(fileSystemName));  
 imp := inttostr(serialNo);  
 Result := imp;  
 end; (*FindVolumeSerial*)  

#Game Cara daftar PointBlank Kaybo

Bila PointBlank INA lagi menten bisa temen-teman mencoba bermain PB Kaybo, disini saya menjelaskan hanya cara mendaftarkan saja, untuk download atau yg lain di lain kesempatan

1. Sebagai contoh menggunakan Google Chrome, install extention chrome : Extension anonymoX

2. buka website http://www.kaybo1.com klik seperti urutan tampilan gambar di atas

 3. Isi formulir, id,email,no. hp bebas di isi asal-asal juga bisa

register sukses

4. Jalankan PointBlankPatcher.exe

5. Isi login game , happy gaming :D

[C++]DWORD xor Encrypt Simple Mode

 // xor byte.cpp : Defines the entry point for the console application.  
 // © heroich.net 20150227   
 #include "stdafx.h"  
 DWORD XorEncryp (DWORD vals, DWORD key)  
 {  
      BYTE * pbyte = (BYTE *) &vals;//misah DWORD ke array byte[]  
      BYTE x[4];   
      //tiap byte di xor  
      for(int i=0;i<4;i++)  
      {  
           x[i]=pbyte[i]^key;  
      }  
      printf( "x: %X \n" ,x[0]);  
      printf( "x: %X \n" ,x[1]);  
      printf( "x: %X \n" ,x[2]);  
      printf( "x: %X \n" ,x[3]);  
      return (x[0]) | (x[1] << 8) | (x[2] << 16) | (x[3] << 24);//gabung byte array to dword  
 }  
 int _tmain(int argc, _TCHAR* argv[])  
 {  
      DWORD dwValues = 0x0BDFA4;//ofset adr DWORD apa aja  
      DWORD ky= 0xC3;//key apa aja  
      DWORD encrypted = XorEncryp(dwValues ,ky);  
      printf( "Encrypted:%08X \n" ,encrypted);  
      DWORD decrypted = XorEncryp(encrypted,ky);  
      printf( "decrypted:%08X \n" ,decrypted);  
      system("pause");  
      return 0;  
 }  

CF Update Map : Jembatan Besar ( 2 Maret 2015 )

Kali ini Tim CrossFire Indonesia menghadirkan Map baru yaitu Jembatan Besar dengan sistem Spesial Time (No death, No respawn Match) serta Senjata Kapsul Koin terbaru yaitu Ultimate Silversmith Set. Dengan adanya senjata baru, tentu akan menambah semangat berperang dan menambah koleksi senjata. Jangan sampai ketinggalan untuk memiliki Senjata ini ya.

Update Map : Jembatan Besar

Item-item baru yang keren akan hadir untuk memeriahkan hebohnya update mode baru kali ini, tentu akan menambah semangat berperang dan menambah koleksi senjata. Kalian dapat melihat ulasan Senjata baru dari gambar dibawah ini :

Keren bukan Update-update yang akan keluar kali ini. Teruslah bermain dengan teman-temanmu dan jadilah prajurit terhebat di CrossFire !!

Terima kasih
Shoot 'em All !!
Tim CrossFire Indonesia

base64.h c++

 #include "  
 static const std::string base64_chars =   
 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  
 "abcdefghijklmnopqrstuvwxyz"  
 "0123456789+/";  
 static inline bool is_base64(unsigned char c) {  
      return (isalnum(c) || (c == '+') || (c == '/'));  
 }  
 std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {  
      std::string ret;  
      int i = 0;  
      int j = 0;  
      unsigned char char_array_3[3];  
      unsigned char char_array_4[4];  
      while (in_len--) {  
           char_array_3[i++] = *(bytes_to_encode++);  
           if (i == 3) {  
                char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;  
                char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);  
                char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);  
                char_array_4[3] = char_array_3[2] & 0x3f;  
                for(i = 0; (i <4) ; i++)  
                     ret += base64_chars[char_array_4[i]];  
                i = 0;  
           }  
      }  
      if (i)  
      {  
           for(j = i; j < 3; j++)  
                char_array_3[j] = '\0';  
           char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;  
           char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);  
           char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);  
           char_array_4[3] = char_array_3[2] & 0x3f;  
           for (j = 0; (j < i + 1); j++)  
                ret += base64_chars[char_array_4[j]];  
           while((i++ < 3))  
                ret += '=';  
      }  
      return ret;  
 }  
 std::string base64_decode(std::string const& encoded_string) {  
      size_t in_len = encoded_string.size();  
      size_t i = 0;  
      size_t j = 0;  
      int in_ = 0;  
      unsigned char char_array_4[4], char_array_3[3];  
      std::string ret;  
      while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {  
           char_array_4[i++] = encoded_string[in_]; in_++;  
           if (i ==4) {  
                for (i = 0; i <4; i++)  
                     char_array_4[i] = static_cast<unsigned char>(base64_chars.find(char_array_4[i]));  
                char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);  
                char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);  
                char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];  
                for (i = 0; (i < 3); i++)  
                     ret += char_array_3[i];  
                i = 0;  
           }  
      }  
      if (i) {  
           for (j = i; j <4; j++)  
                char_array_4[j] = 0;  
           for (j = 0; j <4; j++)  
                char_array_4[j] = static_cast<unsigned char>(base64_chars.find(char_array_4[j]));  
           char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);  
           char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);  
           char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];  
           for (j = 0; (j < i - 1); j++) ret += char_array_3[j];  
      }  
      return ret;  
 }  

Hide Modul c++

 VL::RESULT VL::Hiding::HideModule(HMODULE hMod)  
 {  
      PPEB_LDR_DATA pPMI;  
      PLDR_MODULE pMIN;  
      unsigned int moduleSize = 0;  
      // fetch process module info from peb  
      _asm {  
           mov eax,dword ptr fs:[0x18]  
           mov eax,dword ptr ds:[eax+0x30]  
           mov eax,dword ptr ds:[eax+0x0c]  
           mov pPMI,eax  
      }  
      // search for module  
      pMIN = (PLDR_MODULE)(pPMI->InLoadOrderModuleList.Flink);  
      while (pMIN->BaseAddress && pMIN->BaseAddress != hMod) {  
           pMIN = (PLDR_MODULE)(pMIN->LoadOrder.Flink);  
      }  
      if (!pMIN->BaseAddress) {  
           return LogError(ERR_HIDING_NOTFOUND);  
      }  
      // remove module entrys from linked lists  
      pMIN->LoadOrder.Blink->Flink = pMIN->LoadOrder.Flink;  
      pMIN->LoadOrder.Flink->Blink = pMIN->LoadOrder.Blink;  
      pMIN->InitOrder.Blink->Flink = pMIN->InitOrder.Flink;  
      pMIN->InitOrder.Flink->Blink = pMIN->InitOrder.Blink;  
      pMIN->MemoryOrder.Blink->Flink = pMIN->MemoryOrder.Flink;  
      pMIN->MemoryOrder.Flink->Blink = pMIN->MemoryOrder.Blink;  
      pMIN->HashTable.Blink->Flink = pMIN->HashTable.Flink;  
      pMIN->HashTable.Flink->Blink = pMIN->HashTable.Blink;  
      // erase module name  
      memset(pMIN->FullPath.Buffer, 0, pMIN->FullPath.Length);  
      // erase unused mapped file headers from memory  
      DWORD dwOldProtection;  
      VirtualProtect(pMIN->BaseAddress, 0x1000, PAGE_EXECUTE_READWRITE, &dwOldProtection);  
      memset((void*)pMIN->BaseAddress, 0, 0x1000);  
      VirtualProtect(pMIN->BaseAddress, 0x1000, dwOldProtection, NULL);  
      // erase module info node  
      memset(pMIN, 0, sizeof(pMIN));  
      return ERR_SUCCESS;  
 }  

Download Cheat

download project : mario.rar
USPACK.exe USpack.exe
US-MHS6.1.rar.html
DllLoader
DW_FD_calc DragonNest

Mario Theme & Intro

Beep (330,100);Sleep(100);
        Beep (330,100);Sleep(300);
        Beep (330,100);Sleep(300);
        Beep (262,100);Sleep(100);
        Beep (330,100);Sleep(300);
        Beep (392,100);Sleep(700);
        Beep (196,100);Sleep(700);
        Beep (262,300);Sleep(300);