.... when you jmp with ida to the call...there are somem ore call's etc... i look later for it
![DeathArt - [Tutorial] C++ DLL injection for Main Server - RaGEZONE Forums](http://web27190.web08.talkactive.net/media/shot_2008_3_28_000.jpg "DeathArt - [Tutorial] C++ DLL injection for Main Server - RaGEZONE Forums")
hehe
///
/// Starting Castle Siege
///
DWORD enableSiege = 0x0041C440; // CWar::Start
DWORD startSiege = 0x00419E10; // CCastle::WarBegin
__asm {
call enableSiege
call startSiege
}///
/// Attempting to stop the castle siege (not working)
///
DWORD stopSiege = 0x0041BAF0; // CCastle::SetWarRemainSecondTime
__asm {
push 1
call stopSiege
}
//Some type definitions.. xD
typedef int (* TOneParamter)(int);
typedef int (* TZeroParamter)();
//some functions xD
TOneParamter Caste_SetWarRemainSecondTime = (TOneParamter)0x0041BAF0;
TZeroParamter Caste_Start = (TZeroParamter)0x0041C440;
TZeroParamter Caste_WarBegin = (TZeroParamter)0x00419E10;
....
int MyEvent::Start()
{
Caste_Start();
Caste_WarBegin();
}
....
int MyEvent::End()
{
//You said doesn't work.. hmm I only use it to demonstrate xD
Caste_SetWarRemainSecondTime(1);
}
...function MyFunction(int arg1,int arg2)
{
// function here
}DWORD myFunction = 0x000000; // memory address
int arg1 = 1;
int arg2 = 2;
__asm {
push arg2
push arg1
call myFunction
}Well, the CCastle::SetWarRemainSecondTime don't work
Making memory pointers to methods is ofcource a option, and rather simple,
but I somehow like to attempt a raw ASM workaround first. Because I really don't like pointers.
And yeah, ASM is simple, say if we define a simple function, like this
PHP:function MyFunction(int arg1,int arg2) { __fastcall would be in asm:[/SIZE] // function here }
Then the ASM to call it is the following:
(Yes, parameters in revered order, that's how it's surposed to be)
PHP:DWORD myFunction = 0x000000; // memory address int arg1 = 1; int arg2 = 2; __asm { push arg2 push arg1 call myFunction }
#define Call2Par(x, a, b) __asm{push b; push a; mov edx,x; call edx;}
...
...
Call2Par(0x0000555,Para1,Para2); //would automatical generate your asm ~.~
//should .. I am not sure.. didn't use macros for a long time..push para3
push para2
push para1
call functiontypedef int (* TFunctionType(int,int,int);push para3
push para2
push para1
call function
add esp,0x0C //i think esp need to get moved..typedef int (__cdcdel* TFunctionType(int,int,int);push para3
push para2
push para1
mov ecx,classe //most time used ECX
mov edx,classe //also able to use, maybe ebx i am not sure xD
call functiontypedef int (__fastcall* TFunctionType(int myECX,int myEDX, int,int,int);//i onyl suse this to show basic the parametrs of the functiosn aren't right !!!
void CustomMob()
{
DWORD MyMOB=CMob_Create(...); //you will get a pointer to a class .. this function is i belive a __stdcall
CMob_Spawn(MyMOB,NULL,...); //this function would be a __fastcall
//it's the same like using MyMob->Spawn .. but since we can't use it..
CMob_Delete(MyMOB,NULL); //again __fastcall or the function wont know whos the owner !!
}
/*
I don't know if this functions are existing
or you use these so..
I only wanted to show why it's important to use __fastcall xD
At these functions..
*/Because macro's, and also typedefintions in some cases, is creating extremly messy code, and totaly destroying readability.
You should be able to override any DLL, allowing you to have multiple injectors.
CMob* MyMob = new CMob();
MyMob->Spawn();
MyMob->Move(); //some how get MyMob
CMob_spawn(MyMob,NULL,...);
CMob_move(MyMob,NULL,...);namespace MyNamespace
{
class MyClass
{
public:
static void DoStuff(int arg1);
}
}
namespace MyNamespace
{
MyClass::DoStuff(int arg1)
{
// do stuff
}
}#include "MyClass.h"
using namespace MyNamespace;
int Main()
{
MyClass::DoStuff();
}
