[TUTORIAL] Making a Trainer Using C++ in easiest way

12/09/2012 16:20 Naniooooo#1
19750946]Well most of players want to learn how to create a DLL to inject in cabalmain. Now it's your turn to Create you own DLL using C++.

Take notes: making it simply or coding it in only 1 C++ Files it will result to Complexity so i applied Object Oriented Programming (OOP) to keep it neat, clean, easy to understand and easy to update.

Added Sampe Cheat and Used Multi Level Pointer
-Change Nation
-Movement Speed
-No Cooldown BM2
-Perfect Combo
-No Skill Delay
Requirements
1.) Visual Studio 2005/2008/2010/2012
2.) [Only registered and activated users can see links. Click Here To Register...]
Injector might be use
1.) [Only registered and activated users can see links. Click Here To Register...]
2.) [Only registered and activated users can see links. Click Here To Register...]
3.) [Only registered and activated users can see links. Click Here To Register...]
1.) Run Visual Studio then Click New Project.
2.) Click Win32, Select Win32 Project then Enter the Name of your DLL then hit OK Button
3.) After clicking OK Button, the next window pop-up with “Previous”,”Next”, “Finish”,”Cancel”. Click Next Button
4.) Choose DLL then checked Empty Project then hit Finish Button
5.) After clicking finish, you will see like this.
6.) On Solution Explorer you will add 2 C++ File and 2 Header File.
- Right Click on Header Files > Add > New Item > Select Header File (.h) then name it AllDefines
- Right Click on Header Files > Add > New Item > Select Header File (.h) then name it MyCheat
- Right Click on Source Files > Add > New Item > Select C++ File (.cpp) then name it MainDLL
- Right Click on Source Files > Add > New Item > Select C++ File (.cpp) then name it MyCheat
This is the result after adding files.

Now will add some sample code.
AllDefines.h
MyCheat.h
MyCheat.cpp
MainDLL.cpp

6.) Make it Release to prevent error “msvcp100d.dll”
If you don’t install C++ Redistribution. You will encounter DLL problem.
DEBUG = msvcp100d.dll
RELEASE = msvcp100.dll
7.) Click Build on Menu then Build MySampleDLL
8.) After build DLL you will see “Build succeeded” Now the final step is open the Compiled DLL.
On Solution Explorer Click Show All Files > Right Click Release > Click Open Folder in Windows Explorer.
You will see the MySampleDLL.dll

Special Thanks:
-[Only registered and activated users can see links. Click Here To Register...] for ep9 CE table based on Cabal NA (Support Win 7 32bit and 64bit Only)
-[Only registered and activated users can see links. Click Here To Register...] for Simple C++ Code of AOE

Don't forget to HIT THANKS :D


credits to FUJl
12/10/2012 04:19 iamlegend93#2
it could work, but it would differently need some time too figure out how too code it :D
12/10/2012 11:44 gawron25#3
Little Help

Code:
#include "Form1.h"
#include "Functions.h"
#include <winbase.h>


using namespace Test;

void Main (void)
{
    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);
    Application::Run(gcnew Form1);
    Application::Exit();
}



DWORD ssPotAdyy = 0x008AA348;
DWORD PotReturn = ssPotAdyy+10;
BYTE disablePOT[] = {0x83, 0x78, 0x08, 0x13};

void __declspec(naked) _stdcall PotASM()
{
    __asm
    {
        cmp dword ptr [eax+0x08],0x01 // checking for HP pot?
        jne [check_mana]
        mov dword ptr[eax+0x08],0x11 // change to auto pot
        mov dword ptr[eax+0x10],0x11
        check_mana:
        cmp dword ptr [eax+0x08],0x02
        jne [finished_check]
        mov dword ptr[eax+0x08],0x12 // change to auto pot
        mov dword ptr[eax+0x10],0x12
        finished_check:
        cmp dword ptr [eax+0x08],0x13
        jmp [PotReturn]
    }
}



void Form1::checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
        if(checkBox1->Checked)
    {
        *(BYTE*)ssPotAdyy = 0xE9;
        *(DWORD*)(ssPotAdyy + 1) = jmp(ssPotAdyy, PotASM); 
        }

    else
    {

        WriteMemory(ssPotAdyy, 4, 0x83, 0x78, 0x08, 0x13);
    };

}


DWORD ssZoomAdyy = 0x00654226;
DWORD ZoomReturn = ssZoomAdyy+5;
BYTE disableZoom[] = {0x83, 0x78, 0x08, 0x13, 0x90, 0x90};

void __declspec(naked) _stdcall ZoomASM()
{
    __asm
    {
        mov [edi+0x04],0xFF // change value to maximum zoom
        movss xmm0,[edi+0x04]
        jmp [ZoomReturn]
    }
}


{
    WriteMemory(*0x00654226, 6, 0x83, 0x78, 0x08, 0x13, 0x90, 0x90);
}



void Form1::checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
        if(checkBox2->Checked)
    {
        *(BYTE*)ssZoomAdyy = 0xE9;
        *(DWORD*)(ssZoomAdyy + 1) = jmp(ssZoomAdyy, ZoomASM); 
        }

    else
    {

        WriteMemory(ssZoomAdyy, 6, 0x83, 0x78, 0x08, 0x13, 0x90, 0x90);
    };

}
12/11/2012 00:22 iamlegend93#4
always nice too see people sharing something with the community :)

Even though if everybody got their fingers in this, the game would getting even more destroyed...
12/11/2012 02:23 SkyDrag0n#5
Quote:
Originally Posted by iamlegend93 View Post
always nice too see people sharing something with the community :)

Even though if everybody got their fingers in this, the game would getting even more destroyed...
Wait... It's not already?
12/11/2012 02:44 iamlegend93#6
Quote:
Originally Posted by SkyDrag0n View Post
Wait... It's not already?
yeah u right... lost all my gear back in august and haven't seen even one single piece of it yet..
gms keep saying, we are investigeting the issue .. dafq
12/11/2012 08:07 Naniooooo#7
XD
you can find nice things at cabal section
by the way any1 know where i can find gameguard bypass ?
12/29/2012 19:17 gawron25#8
Form1.cpp

Code:
#include <windows.h>
#include "Form1.h"
#include "Functions.h"



using namespace Dekaron_Boost;


void Android(void)
{

    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);
    Application::Run(gcnew Dekaron);
    Application::Exit();
}


//AutoPot

DWORD ssPotAdyy = 0x008C17B8;
DWORD PotReturn = ssPotAdyy+10;
BYTE disablePOT[] = {0x83, 0x78, 0x08, 0x13};

void PotASM()
{
    __asm
    {
        cmp dword ptr [eax+0x08],0x01 // checking for HP pot?
        jne [check_mana]
        mov dword ptr[eax+0x08],0x11 // change to auto pot
        mov dword ptr[eax+0x10],0x11
        check_mana:
        cmp dword ptr [eax+0x08],0x02
        jne [finished_check]
        mov dword ptr[eax+0x08],0x12 // change to auto pot
        mov dword ptr[eax+0x10],0x12
        finished_check:
        cmp dword ptr [eax+0x08],0x13
        jmp [PotReturn]
    }
}

void Dekaron::checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox1->Checked)
         {
        *(BYTE*)ssPotAdyy = 0xE9; 
        *(DWORD*)(ssPotAdyy + 1) = jmp(ssPotAdyy, PotASM); 
         }
     else 
        { 
        WriteMemory(ssPotAdyy, 4, 0x83, 0x78, 0x08, 0x13);
         }
}


//Minimap Tele

DWORD ssteleAdyy = 0x0056B023;
DWORD teleReturn = ssPotAdyy+7;
BYTE disabletele[] = {0x8B, 0x80, 0xA0, 0x00, 0x00, 0x00, 0xC3};

void __declspec(naked) _stdcall teleASM()
{
    __asm
    {
        mov eax,00000003
        nop
        ret
        jmp [teleReturn]
    }
}
void Dekaron::checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox2->Checked)
         {
        *(BYTE*)ssteleAdyy = 0xE9; 
        *(DWORD*)(ssteleAdyy + 1) = jmp(ssteleAdyy, teleASM); 
         }
     else 
        { 
        WriteMemory(ssteleAdyy, 7, 0x8B, 0x80, 0xA0, 0x00, 0x00, 0x00, 0xC3);
         }
}


//WallHack

DWORD sswallAdyy = 0x0086BAE9;
DWORD wallReturn = sswallAdyy+12;
BYTE disablewall[] = {0xFF, 0x50, 0x10, 0x8B, 0xF0, 0x8D, 0xBC, 0x24, 0x88, 0x00, 0x00, 0x00, 0xB9, 0x75, 0x04, 0x00, 0x00, 0xF3, 0xA5};

void __declspec(naked) _stdcall wallASM()
{
    __asm

    {
        call dword ptr [eax+0x10]
        mov esi,eax
        lea edi,ss:[esp+0x00000088]
    cmp dword ptr [eax+0x00000402],0x5F626577
        je [check_wall]
    check_wall:
    mov dword ptr [eax+0x00000402],0x5F626577
    mov dword ptr [eax+0x00000406],0x67616D69
    mov dword ptr [eax+0x0000040A],0x616D2E65
    mov dword ptr [eax+0x0000040E],0x00000063
        jmp [wallReturn]

    }
}

void Dekaron::checkBox3_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox3->Checked)
         {
        *(BYTE*)sswallAdyy = 0xE9; 
        *(DWORD*)(sswallAdyy + 1) = jmp(sswallAdyy, wallASM); 
         }
     else 
        { 
        WriteMemory(sswallAdyy, 19, 0xFF, 0x50, 0x10, 0x8B, 0xF0, 0x8D, 0xBC, 0x24, 0x88, 0x00, 0x00, 0x00, 0xB9, 0x75, 0x04, 0x00, 0x00, 0xF3, 0xA5);
         }
}


//SkillHack

DWORD ssskillAdyy = 0x00506C14;
DWORD skillReturn = ssskillAdyy+6;
BYTE disablekill[] = {0x55, 0x8B, 0xCE, 0x88, 0x47, 0x61};

void __declspec(naked) _stdcall ssskillASM()
{
    __asm
    {
        push ebp
        mov ecx,esi
        mov [edi+0x61],0x0a1
        jmp [skillReturn]
    }
}

void Dekaron::checkBox4_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox4->Checked)
         {
        *(BYTE*)ssskillAdyy = 0xE9;
        *(DWORD*)(ssskillAdyy + 1) = jmp(ssskillAdyy, ssskillASM); 
         }
     else 
        { 
        WriteMemory(ssskillAdyy, 6, 0x55, 0x8B, 0xCE, 0x88, 0x47, 0x61);
         }
}

//PetHack+NoAnim

DWORD Pdelay1 = 0x004BF3B9;
DWORD Pdelay2 = 0x004BF482;
DWORD Pdelay3 = 0x004BF551;
DWORD Pattack1 = 0x004BF43C;
DWORD Pattack2 = 0x004BF505;
DWORD Pattack3 = 0x004BF5D2;

BYTE enableattack1[] = {0xC7, 0x44, 0x24, 0x24, 0x07, 0x00, 0x00, 0x00};
BYTE enableattack2[] = {0xC7, 0x44, 0x24, 0x24, 0x07, 0x00, 0x00, 0x00};
BYTE enableattack3[] = {0xC7, 0x44, 0x24, 0x20, 0x07, 0x00, 0x00, 0x00};
BYTE disableattack1[] = {0xC7, 0x44, 0x24, 0x24, 0x04, 0x00, 0x00, 0x00};
BYTE disableattack2[] = {0xC7, 0x44, 0x24, 0x24, 0x06, 0x00, 0x00, 0x00};
BYTE disableattack3[] = {0xC7, 0x44, 0x24, 0x20, 0x05, 0x00, 0x00, 0x00};
BYTE enabledelay1[] = {0x8B, 0x68, 0x01};
BYTE enabledelay2[] = {0x8B, 0x68, 0x01};
BYTE enabledelay3[] = {0x8B, 0x68, 0x01};
BYTE disabledelay1[] = {0x8B, 0x68, 0x20};
BYTE disabledelay2[] = {0x8B, 0x68, 0x28};
BYTE disabledelay3[] = {0x8B, 0x68, 0x30};

DWORD ssnoanimAdyy = 0x005C334B;
DWORD noanimReturn = ssnoanimAdyy+6;
BYTE disablenoanim[] = {0xD8, 0x8B, 0x14, 0x01, 0x00, 0x00};

void __declspec(naked) _stdcall noanimASM()
{
    __asm
    {
        mov dword ptr [ebx+0x00000114],0x3C0CCDCC
        fmul dword ptr [ebx+0x00000114]
        jmp [noanimReturn]
    }
}

void Dekaron::checkBox5_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox5->Checked)
         {
        memcpy((void*)Pdelay1, enabledelay1, sizeof(enabledelay1));
        memcpy((void*)Pdelay2, enabledelay2, sizeof(enabledelay2));
        memcpy((void*)Pdelay3, enabledelay3, sizeof(enabledelay3));
        memcpy((void*)Pattack1, enableattack1, sizeof(enableattack1));
        memcpy((void*)Pattack2, enableattack2, sizeof(enableattack2));
        memcpy((void*)Pattack3, enableattack3, sizeof(enableattack3));
        *(BYTE*)ssnoanimAdyy = 0xE9; 
        *(DWORD*)(ssnoanimAdyy + 1) = jmp(ssnoanimAdyy, noanimASM);
         }
         else
         {
        memcpy((void*)Pdelay1, disabledelay1, sizeof(disabledelay1));
        memcpy((void*)Pdelay2, disabledelay2, sizeof(disabledelay2));
        memcpy((void*)Pdelay3, disabledelay3, sizeof(disabledelay3));
        memcpy((void*)Pattack1, disableattack1, sizeof(disableattack1));
        memcpy((void*)Pattack2, disableattack2, sizeof(disableattack2));
        memcpy((void*)Pattack3, disableattack3, sizeof(disableattack3));
        WriteMemory(ssnoanimAdyy, 6, 0xD8, 0x8B, 0x14, 0x01, 0x00, 0x00);
         }
}


//NonAggro

DWORD aggro1Adyy = 0x005BE6F7;
DWORD aggro1Return = aggro1Adyy+6;
BYTE disableaggro1[] = {0x89, 0x4C, 0x24, 0x48, 0x8B, 0x4F, 0x0C};



void __declspec(naked) _stdcall aggro1ASM()
{
    __asm
    {
        mov [esp+0x48],ecx
        mov [esp+0x30],0x00000000
        mov [esp+0x4C],0x00000000
        mov [esi+0x0000029C],0x00000000
        mov [esi+0x000002D4],0x00000000
        mov [esi+0x000003B4],0x00000000
        mov [esi+0x000003EC],0x00000000
        mov [esi+0x00000424],0x00000000
        mov [esi+0x0000045C],0x00000000
        mov [esi+0x00000240],0x00000000
        mov [esi+0x0000023C],0x00000000
        mov [esi+0x00000238],0x00000000
        mov ecx,[edi+0x0C]
        jmp [aggro1Return]
    }
}

DWORD aggro2Adyy = 0x005BE70F;
DWORD aggro2Return = aggro2Adyy+7;
BYTE disableaggro2[] = {0x0F, 0xB7, 0x86, 0x64, 0x01, 0x00, 0x00};

void __declspec(naked) _stdcall aggro2ASM()
{
    __asm
    {
        movzx eax,word ptr [esi+0x00000160]
        mov byte ptr [esi+0x00000180],0x00
        mov byte ptr [esi+0x00000250],0x00
        mov dword ptr [esi+0x0000024C],0x00000000
        mov dword ptr [esi+0x00000248],0x00000000
        mov dword ptr [esi+0x00000244],0x00000000
        mov eax,0x00000006
        mov [esi+0x00000160],ax
        jmp [aggro2Return]
    }
}


void Dekaron::checkBox6_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox6->Checked)
         {
        *(DWORD*)aggro1Adyy = 0xE9; 
        *(DWORD*)aggro2Adyy = 0xE9;
        *(DWORD*)(aggro1Adyy + 1) = jmp(aggro1Adyy, aggro1ASM);
        *(DWORD*)(aggro2Adyy + 1) = jmp(aggro2Adyy, aggro2ASM); 
         }
     else 
        { 
        WriteMemory(aggro1Adyy, 7, 0x89, 0x4C, 0x24, 0x48, 0x8B, 0x4F, 0x0C);
        WriteMemory(aggro2Adyy, 7, 0x0F, 0xB7, 0x86, 0x64, 0x01, 0x00, 0x00);
         }
}


DWORD ssdillAdyy = 0x005D265E;
DWORD dillReturn = ssPotAdyy+5;
BYTE disabledill[] = {0x5F, 0x5E, 0xC2, 0x04, 0x00};
#define FuncToCall 0x00566980
DWORD myfunc = FuncToCall;
BYTE *blah3 = new BYTE[2024]; 






    

void __declspec(naked) _stdcall dillASM()
{
    __asm
    {
        mov bx,[edi+0x10]
        mov eax,blah3 
        mov dword ptr [eax],0xE7395B84
        mov dword ptr [eax+0x04],0x00180000
        mov dword ptr [eax+0x08],0x00000000
        mov dword ptr [eax+0x0C],0x05030003
        mov dword ptr [eax+0x10],0x00000500
        mov [eax+0x14],bx
        mov word ptr [eax+0x16],0x1000
        mov ecx,[0x00CA01B0]
        mov bx,0x0001
        push eax
        __asm call dword ptr [myfunc];
        mov ax,0x0001
        pop edi
        pop esi
        ret 0004
        
    }
}
void Dekaron::checkBox7_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox7->Checked)
         {
        *(BYTE*)ssdillAdyy = 0xE9; 
        *(DWORD*)(ssdillAdyy + 1) = jmp(ssdillAdyy, dillASM); 
         }
     else 
        { 
        WriteMemory(ssdillAdyy, 5, 0x5F, 0x5E, 0xC2, 0x04, 0x00);
         }
}
Form1.h

Code:
#pragma once

using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;


namespace Dekaron_Boost {

    /// <summary>
    /// Summary for Dekaron_Boost
    ///
    /// WARNING: If you change the name of this class, you will need to change the
    ///          'Resource File Name' property for the managed resource compiler tool
    ///          associated with all .resx files this class depends on.  Otherwise,
    ///          the designers will not be able to interact properly with localized
    ///          resources associated with this form.
    /// </summary>
    public ref class Dekaron : public System::Windows::Forms::Form
    {
    public:
        Dekaron(void)
        {
            InitializeComponent();
            //
            //TODO: Add the constructor code here
            //
        }

    protected:
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        ~Dekaron()
        {
            if (components)
            {
                delete components;
            }
        }
    protected: System::Windows::Forms::CheckBox^  checkBox1;
    protected: System::Windows::Forms::CheckBox^  checkBox2;
    protected: System::Windows::Forms::CheckBox^  checkBox3;
    protected: System::Windows::Forms::CheckBox^  checkBox5;
    protected: 





    protected: System::Windows::Forms::CheckBox^  checkBox4;



    protected: System::Windows::Forms::CheckBox^  checkBox6;
    protected: System::Windows::Forms::CheckBox^  checkBox7;
    protected: System::Windows::Forms::Button^  button1;




    protected: System::ComponentModel::IContainer^  components;








    protected:
        /// <summary>
        /// Required designer variable.
        /// </summary>


#pragma region Windows Form Designer generated code
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        void InitializeComponent(void)
        {
            this->checkBox1 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox2 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox3 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox5 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox4 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox6 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox7 = (gcnew System::Windows::Forms::CheckBox());
            this->button1 = (gcnew System::Windows::Forms::Button());
            this->SuspendLayout();
            // 
            // checkBox1
            // 
            this->checkBox1->AutoSize = true;
            this->checkBox1->Location = System::Drawing::Point(12, 12);
            this->checkBox1->Name = L"checkBox1";
            this->checkBox1->Size = System::Drawing::Size(71, 19);
            this->checkBox1->TabIndex = 0;
            this->checkBox1->Text = L"AutoPot";
            this->checkBox1->UseVisualStyleBackColor = true;
            this->checkBox1->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox1_CheckedChanged);
            // 
            // checkBox2
            // 
            this->checkBox2->AutoSize = true;
            this->checkBox2->Location = System::Drawing::Point(12, 37);
            this->checkBox2->Name = L"checkBox2";
            this->checkBox2->Size = System::Drawing::Size(99, 19);
            this->checkBox2->TabIndex = 2;
            this->checkBox2->Text = L"MiniMap Tele";
            this->checkBox2->UseVisualStyleBackColor = true;
            this->checkBox2->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox2_CheckedChanged);
            // 
            // checkBox3
            // 
            this->checkBox3->AutoSize = true;
            this->checkBox3->Location = System::Drawing::Point(12, 62);
            this->checkBox3->Name = L"checkBox3";
            this->checkBox3->Size = System::Drawing::Size(80, 19);
            this->checkBox3->TabIndex = 4;
            this->checkBox3->Text = L"WallHack";
            this->checkBox3->UseVisualStyleBackColor = true;
            this->checkBox3->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox3_CheckedChanged);
            // 
            // checkBox5
            // 
            this->checkBox5->AutoSize = true;
            this->checkBox5->Location = System::Drawing::Point(12, 112);
            this->checkBox5->Name = L"checkBox5";
            this->checkBox5->Size = System::Drawing::Size(74, 19);
            this->checkBox5->TabIndex = 5;
            this->checkBox5->Text = L"PetHack";
            this->checkBox5->UseVisualStyleBackColor = true;
            this->checkBox5->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox5_CheckedChanged);
            // 
            // checkBox4
            // 
            this->checkBox4->AutoSize = true;
            this->checkBox4->Location = System::Drawing::Point(12, 87);
            this->checkBox4->Name = L"checkBox4";
            this->checkBox4->Size = System::Drawing::Size(79, 19);
            this->checkBox4->TabIndex = 6;
            this->checkBox4->Text = L"SkillHack";
            this->checkBox4->UseVisualStyleBackColor = true;
            this->checkBox4->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox4_CheckedChanged);
            // 
            // checkBox6
            // 
            this->checkBox6->AutoSize = true;
            this->checkBox6->Location = System::Drawing::Point(12, 137);
            this->checkBox6->Name = L"checkBox6";
            this->checkBox6->Size = System::Drawing::Size(82, 19);
            this->checkBox6->TabIndex = 9;
            this->checkBox6->Text = L"NonAggro";
            this->checkBox6->UseVisualStyleBackColor = true;
            this->checkBox6->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox6_CheckedChanged);
            // 
            // checkBox7
            // 
            this->checkBox7->AutoSize = true;
            this->checkBox7->Location = System::Drawing::Point(12, 163);
            this->checkBox7->Name = L"checkBox7";
            this->checkBox7->Size = System::Drawing::Size(85, 19);
            this->checkBox7->TabIndex = 10;
            this->checkBox7->Text = L"Pickup DIll";
            this->checkBox7->UseVisualStyleBackColor = true;
            this->checkBox7->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox7_CheckedChanged);
            // 
            // button1
            // 
            this->button1->AutoSize = true;
            this->button1->AutoSizeMode = System::Windows::Forms::AutoSizeMode::GrowAndShrink;
            this->button1->BackColor = System::Drawing::SystemColors::ControlLight;
            this->button1->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Center;
            this->button1->Dock = System::Windows::Forms::DockStyle::Bottom;
            this->button1->Font = (gcnew System::Drawing::Font(L"Gill Sans Ultra Bold", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, 
                static_cast<System::Byte>(238)));
            this->button1->ForeColor = System::Drawing::Color::Black;
            this->button1->Location = System::Drawing::Point(0, 331);
            this->button1->Name = L"button1";
            this->button1->Size = System::Drawing::Size(362, 29);
            this->button1->TabIndex = 11;
            this->button1->Text = L"Terminate Dekaron";
            this->button1->UseVisualStyleBackColor = false;
            this->button1->Click += gcnew System::EventHandler(this, &Dekaron::button1_Click_1);
            // 
            // Dekaron
            // 
            this->AccessibleDescription = L"";
            this->AccessibleName = L"";
            this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::None;
            this->AutoSizeMode = System::Windows::Forms::AutoSizeMode::GrowAndShrink;
            this->BackColor = System::Drawing::Color::Black;
            this->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch;
            this->ClientSize = System::Drawing::Size(362, 360);
            this->Controls->Add(this->button1);
            this->Controls->Add(this->checkBox7);
            this->Controls->Add(this->checkBox6);
            this->Controls->Add(this->checkBox4);
            this->Controls->Add(this->checkBox5);
            this->Controls->Add(this->checkBox3);
            this->Controls->Add(this->checkBox2);
            this->Controls->Add(this->checkBox1);
            this->Font = (gcnew System::Drawing::Font(L"Arial", 9, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0)));
            this->ForeColor = System::Drawing::Color::Transparent;
            this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D;
            this->Name = L"Dekaron";
            this->ShowIcon = false;
            this->ShowInTaskbar = false;
            this->StartPosition = System::Windows::Forms::FormStartPosition::Manual;
            this->Text = L"Alien Panther  [xGawronx]";
            this->Load += gcnew System::EventHandler(this, &Dekaron::Dekaron_Load);
            this->ResumeLayout(false);
            this->PerformLayout();

        }
#pragma endregion
    protected: System::Void Dekaron_Load(System::Object^  sender, System::EventArgs^  e) {
             }
protected: System::Void checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox3_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox4_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox5_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox6_CheckedChanged(System::Object^  sender, System::EventArgs^  e);

protected: System::Void checkBox7_CheckedChanged(System::Object^  sender, System::EventArgs^  e);

protected: System::Void button1_Click_1(System::Object^  sender, System::EventArgs^  e) {

             ExitProcess(0);
         }
};
}
Functions.h

Code:
#include <Windows.h>

#define jmp(frm, to) (int)(((int)to - (int)frm) - 5)
#define jne(frm, to) (int)(((int)to - (int)frm) - 5)
#define je(frm, to) (int)(((int)to - (int)frm) - 5)




// don't do anything, it's not a functioni

DWORD ReadPointer1(CONST LPDWORD lpdwBase, CONST INT iOffset) {     __try { return *(LPDWORD)(*lpdwBase + iOffset); }     __except (EXCEPTION_EXECUTE_HANDLER) { return NULL; } }


//Reads a Pointer
unsigned long ReadPointer(unsigned long ulBase, int iOffset) //Now look at my read pointer.
{
    __try { return *(unsigned long*)(*(unsigned long*)ulBase + iOffset); }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}

//Reads Negative Pointers
int ReadNegativePointer(int ulBase, int iOffset)
{
    __try { return *(int*)(*(int*)ulBase + iOffset); }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}
//Writes a Pointer
bool WritePointer(unsigned long ulBase, int iOffset, int iValue)
{
    __try { *(int*)(*(unsigned long*)ulBase + iOffset) = iValue; return true; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}

unsigned long GetPointedAddress(unsigned long ulBase, int iOffset)
{
    __try { return *(unsigned long*)ulBase + iOffset; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}


bool WriteValue(unsigned long ulBase, int iOffset, int iValue)
{
    __try { *(int*)(ulBase + iOffset) = iValue; return true; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}
//WritePointer Function---------------------------------------------------------------------
void Memory(PVOID address, void* val, int bytes)
{
    DWORD d, ds;
    VirtualProtect(address, bytes, PAGE_EXECUTE_READWRITE, &d);
    memcpy(address, val, bytes);
    VirtualProtect(address,bytes,d,&ds);
}

//waitn
void MakePageWritable(unsigned long ulAddress, unsigned long ulSize)
{
    MEMORY_BASIC_INFORMATION* mbi = new MEMORY_BASIC_INFORMATION;
    VirtualQuery((void*)ulAddress, mbi, ulSize);
    if (mbi->Protect != PAGE_EXECUTE_READWRITE)
    {
        unsigned long* ulProtect = new unsigned long;
        VirtualProtect((void*)ulAddress, ulSize, PAGE_EXECUTE_READWRITE, ulProtect);
        delete ulProtect;
    }

    delete mbi;
}



//CALL Function------------------------------------------------------
bool Call(unsigned long ulAddress, void* Function, unsigned long ulNops) 
{ 
    __try 
    {  
        *(unsigned char*)ulAddress = 0xE8; 
        *(unsigned long*)(ulAddress + 1) = jmp(ulAddress, Function);  
        memset((void*)(ulAddress + 5), 0x90, ulNops); 
        return true; 
    } 
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; } 
}
//JMPCALL Function------------------------------------------------------
inline DWORD_PTR jmpcall(LPCVOID lpcvSrc, LPCVOID lpcvDest)
{
    return reinterpret_cast<DWORD_PTR>(lpcvDest) - reinterpret_cast<DWORD_PTR>(lpcvSrc) - 5;
}


//MakePageRWX Function------------------------------------------------------
bool MakePageRWX(LPCVOID lpcvMemory)
{
    MEMORY_BASIC_INFORMATION mbiInfo;
    SecureZeroMemory(&mbiInfo, sizeof(MEMORY_BASIC_INFORMATION));

    if (VirtualQuery(lpcvMemory, &mbiInfo, sizeof(mbiInfo)) == 0)
        return false;

    if (mbiInfo.Protect != PAGE_EXECUTE_READWRITE)
    {
        DWORD dwProtect = 0;
        return (VirtualProtect(const_cast<LPVOID>(lpcvMemory), mbiInfo.RegionSize, PAGE_EXECUTE_READWRITE, &dwProtect) != FALSE);
    }

    return true;
}




//JUMPCALL Function------------------------------------------------------
bool JumpCall(bool fJump, const LPBYTE lpbAddress, LPCVOID lpcvHook, const LPBYTE lpbBuffer, size_t cNops)
{
    if (MakePageRWX(reinterpret_cast<LPCVOID>(lpbAddress)))
    {
        if (lpbBuffer != NULL)
            memcpy(reinterpret_cast<void*>(lpbBuffer), reinterpret_cast<const void*>(lpbAddress), cNops + 5);

        *lpbAddress = (fJump ? 0xE9 : 0xE8);
        *reinterpret_cast<LPDWORD>(lpbAddress + 1) = jmpcall(lpbAddress, lpcvHook);

        if (cNops)
            memset(reinterpret_cast<void*>(lpbAddress + 5), 0x90, cNops);

        return true;
    }

    return false;
}


void WriteMemory( unsigned long ulAddress, unsigned char ucAmount, ...)   
{ 
    //MakePageWritable(ulAddress, (unsigned long)ucAmount); //Make memory writable before any modifications are attempted 
    DWORD dwOldProtect; 
    VirtualProtect((void*)ulAddress, ucAmount, PAGE_EXECUTE_READWRITE, &dwOldProtect);//Unprotect memory 

    va_list* va = new va_list; 
    va_start(*va, ucAmount); 

    for (unsigned char ByteToWrite = va_arg(*va, unsigned char), ucIndex = 0; ucIndex < ucAmount; ucIndex++, ByteToWrite = va_arg(*va, unsigned char)) 
    { 
        *(unsigned char*)(ulAddress + ucIndex) = ByteToWrite; 
    } 

    va_end(*va); 
    delete va; 

    VirtualProtect((void*)ulAddress, ucAmount, dwOldProtect, &dwOldProtect);//revert back to the original. 
}
MainDLL.ccp

Code:
#include <windows.h>

extern void Android(void);

::BOOL WINAPI DllWork (__in ::HMODULE hModule )
{
    Android();
    return true;
}

::BOOL WINAPI DllMain ( __in ::HMODULE hModule, __in ::DWORD dwReason, __in __reserved ::LPVOID lpvReserved )
{
    ::HANDLE hThread = NULL;

    if ( dwReason == DLL_PROCESS_ATTACH ) 
    {
        if (( hThread = ::CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&DllWork, (::HMODULE)hModule, 0, NULL) ) == NULL ) 
        {
            return FALSE;
        }
        if ( ::CloseHandle(hThread) == FALSE )
        {
                      //do nothing
        }
    }
    return TRUE;
}
01/02/2013 23:49 iCraziE#9
I tried building this but i get these errors..

---------------------------------------------

EDIT::: Never mind, I figured it out :)

----------------------------------------------

EDIT2 :: Now I get this when injecting the dll


heres the warnings when building...


EDIT3 :: Changed the properties to No CLR Support and now i Just get only the C4793 warnings,
I can still injected the dll but im wondering if the warnings are going to be an issue.
01/03/2013 15:12 superlols#10
Code:
1>------ Build started: Project: DK_Hacks, Configuration: Release Win32 ------
1>  Form1.cpp
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(3): error C2871: 'System' : a namespace with this name does not exist
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(4): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(4): error C2871: 'ComponentModel' : a namespace with this name does not exist
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(5): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(5): error C2871: 'Collections' : a namespace with this name does not exist
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(6): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(6): error C2871: 'Forms' : a namespace with this name does not exist
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(7): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(7): error C2871: 'Data' : a namespace with this name does not exist
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(8): error C2653: 'System' : is not a class or namespace name
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(8): error C2871: 'Drawing' : a namespace with this name does not exist
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2059: syntax error : 'public'
1>c:\users\...\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2059: syntax error : 'public'
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2143: syntax error : missing ';' before '{'
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2447: '{' : missing function header (old-style formal list?)
1>Form1.cpp(338): fatal error C1004: unexpected end-of-file found
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
i'am using the .h from gawron but still giving me errors :/
01/03/2013 18:42 iCraziE#11
when u create the solution.. instead of making form1.h a header file. right click the header files hit add new, click on windows form, or form.. and label it Form1.h
then when you click form1.h, press F7 or double click the form to view the code.

paste the code gawron provided for form1.h there. also the form1.cpp info should go in the cpp file it creates in the headers section.