Speicherbereich ausführen

Guten Abend ich wollte mal Fragen wieso der folgende Quelltext eine Access Violation hervorruft. Da dieser Quelltext eigentlich aus meiner sich Einwandfrei klappen müsste. Achtung es wird inline Assembler benutzt!

void TheCallingFunction(void)
{
 cout<<"Funktion wurde aufgerufen"<<endl;
}
unsigned long BerechneOffset(unsigned long absprungaddr,unsigned long Zieladdr)
{
 unsigned long sprungweite=0;
 absprungaddr+=5;//Da der Assembler jump Befhel von bytes groß ist 
//und der Compiler erst nach diesen 5 bytes springt
sprungweite=Zieladdr-absprungaddr;
 return sprungweite;
}
int main(int argumentvalue,char **arguments)
{
unsigned char *Saveplace=new unsigned char[5];
//5 Bytes reservieren
//1 byte = jump binär ist 0xE9 =1 Byte
//4 Byte für unsigned long Sprungweg
unsigned long sprungweg=BerechneOffset((unsigned long)Saveplace,(unsigned long)&TheCallingFunction);
//Sprungweite berechnen
unsigned char JmpByte=0xE9;
_asm
 {
[asm]
 mov ebx,Saveplace ; In Register ebx die Addresse vom reservierten Speicher schreiben
 mov al,[JmpByte] ; In das low byte von eax den Inhalt von JmpByte schreiben =0xE9
 mov [ebx],al ; Das Low Byte kopieren und den Wert welcher an der Addresse von ebx steht ersetzen
 add ebx,1 ; die Addresse welche auf die ebx zeigt um eins erhöhen
 mov eax,[sprungweg] ; Inhalt von Sprungweg nach eax kopieren
 mov [ebx],eax ; eax in den Inhalt von ebx kopieren
 jmp Saveplace ; Springe zur Addresse an der der geschriebene Code steht
[/asm]
 }

system("Pause");
return 0;
}
Sofort nach jmp stützt das Programm ab die Funktion wird nicht aufgerufen

yihaaa

1. Es fehlt ein delete.
2. System( "Pause" ); sollte man nicht verwenden.
3. Entweder du erstellst dir eine Heap oder du gibst dir mit VirtualProtect die nötigen Rechte.
4. Das sind C-Casts.
5. Du hast den flaschen OP-Code genommen es muss 0xE8 sein, desweitern fehlt ein Byte, da du ja noch ein RET brauchst.

MfG

Edit: Hab mal bei meinen alten Sachen gesucht und etwas Vergleichbares gefunden:

#include <iostream>
#include <windows.h>

#pragma optimize( "", off )

#pragma pack( push, 1 )
typedef struct myMessageBoxA
{
	BYTE push_address_1;
	BYTE arg_1;

	BYTE push_address_2;
	DWORD address_2;

	BYTE push_address_3;
	DWORD address_3;

	BYTE push_address_4;
	BYTE arg_4;

	BYTE call;
	DWORD _MessageBox;

	BYTE ret;
}myMessageBoxA;
#pragma pack( pop )

int main( char* arg, char* arvg[ ] )
{
	char* Text = "Hallo";
	char* Title = "Test";
	DWORD addr = reinterpret_cast< DWORD >( &MessageBoxA );

	myMessageBoxA* MyBox;
	ZeroMemory( MyBox, sizeof( myMessageBoxA ) );

	HANDLE m_pHeap = HeapCreate( HEAP_CREATE_ENABLE_EXECUTE, NULL, NULL );
MyBox = reinterpret_cast< myMessageBoxA* >( HeapAlloc( m_pHeap, NULL, sizeof( myMessageBoxA ) ) );

	addr = addr - reinterpret_cast< DWORD >( MyBox ) - 0x13; //Relativ Call!

	MyBox->push_address_1 = 0x6A;
	MyBox->push_address_2 = 0x68;
	MyBox->push_address_3 = 0x68;
	MyBox->push_address_4 = 0x6A;
	MyBox->arg_1 = NULL;
	MyBox->arg_4 = NULL;
	MyBox->address_2 = reinterpret_cast< DWORD >( Text );
	MyBox->address_3 = reinterpret_cast< DWORD >( Title );
	MyBox->call = 0xE8;

	MyBox->_MessageBox = addr;
	MyBox->ret = 0xC3;

	__asm call MyBox;

	HeapFree( m_pHeap, NULL, MyBox );
	HeapDestroy( m_pHeap );

	std::cout << "Alles hat funktioniert !" << std::endl;

	return 0;
}

#pragma optimize( "", on )

Ich hoffe das hilft dir etwas.

Vielen Dank für die Antwort werde mich gleich mal in deinen Code reinarbeiten^^