Suche Programmieridee

MrSm!th · 10/07/2010, 08:45

Quote:

Originally Posted by lolkop

dlls in autoit schreiben ist natürlich schwachsinn. aber autoit funktionen in asm übersetzen wäre extrem nützlich :P

man kann ja klein anfangen und sich denn langsam hocharbeiten. wenn man das ganze weit ausarbeitet, ist es zb deutlich einfacher umfangreiche codecves in autoit umzusetzen

^this

schreib ne udf, die einem code injection erleichtert

also eine, die einem den autoit code in asm übersetzt und ihn dann in prozess schreibt.

PenGuin :O · 10/07/2010, 13:47

Es gibt schon eine FASM UDF für Autoit, sodass du in AutoIt ASM programmieren kannst.
Und nun soll ich eine UDF schreiben mti der man seinen Autoit Code in asm übersetzen lassen kann?! o.O

| Moep | · 10/07/2010, 13:52

Lern C!

lolkop · 10/07/2010, 14:41

Quote:

Originally Posted by pinguin94

Es gibt schon eine FASM UDF für Autoit, sodass du in AutoIt ASM programmieren kannst.
Und nun soll ich eine UDF schreiben mti der man seinen Autoit Code in asm übersetzen lassen kann?! o.O

die udf die es gibt is im prinziep nutzlos, da sie einfach nur hexcodes durch längere strings (asm befehle) ersetzt. hierbei geht es darum das man beispielsweise eine funktion wie _MsgBox so schreibt, das sie rein über asm befehle ausgeführt wird (bzw über die dlls die eigtnlich sowieso in jedem process geladen werden). das hört sich vielleicht schwer an, ist es aber eigentlich garnicht =)

man müsste sich halt eine zugehörigkeitsliste von funktionen und dlls erstellen, und dann jeweils die dll im prozess ansprechen.

MrSm!th · 10/08/2010, 16:27

Quote:

Originally Posted by pinguin94

Es gibt schon eine FASM UDF für Autoit, sodass du in AutoIt ASM programmieren kannst.
Und nun soll ich eine UDF schreiben mti der man seinen Autoit Code in asm übersetzen lassen kann?! o.O

nein nein, ich meine du übergibst der udf den string mit den asm befehlen und bekommst ein array mit den opcodes zurück.
dann noch ne funktion mit der man diesen code ganz einfach injekten und nen jmp darauf lenken lassen kann, dann wäre autoit in gewissen situationen bequehmer als c++ :>

PenGuin :O · 10/08/2010, 16:36

Hmm gut, dann brauch ich ne Liste von allen Befehlen und den dazugehörigen Opcodes^^

Die einzige Funktion zum Injecten fällt mir die für DLLs nur ein:

Code:

Func InjectDLL($hWnd,$DllPath)
	If IsHWnd($hWnd) = 0 Then
		SetError(-1)
		Return False
	ElseIf StringLen($DllPath)<= 4 OR Stringright($DllPath, 4) <> ".dll" Then
		SetError(-2)
		Return False
	EndIf
	Local $PID,$PHandle,$PLibRemote,$ModHandle,$LoadLibRarya,$HthRead
	Local $Kernel32 = DllOpen("kernel32.dll")
	If $Kernel32 = -1 Then
		Exit
	EndIf
	$PID = DLLCall("user32.dll","int","GetWindowThreadProcessId","hwnd",$hWnd,"int*",0)
	If IsArray($PID) Then
		$PID=$PID[2]
	Else
		SetError(-3)
		Return False
	EndIf
	$PHandle = DLLCall($Kernel32,"int","OpenProcess","int",2035711,"int",0,"int",$PID)
	If IsArray($PHandle) And $PHandle[0] > 0 Then
		$PHandle = $PHandle[0]
	ELSE
		SetError(-4)
		Return False
	EndIf
	$PLibRemote = DLLCall($Kernel32,"int","VirtualAllocEx","int",$PHandle,"short",0,"int",4096,"int",4096,"int",4)
	If IsArray($PLibRemote) Then
		If $PLibRemote[0] > 0 Then
			$PLibRemote = $PLibRemote[0]
		Else
			SetError(-5)
			Return False
		EndIf
	Else
		SetError(-6)
		Return False
	EndIf
	For $i = 0 To StringLen($DllPath)
		$Ret = DLLCall("kernel32.dll","int","WriteProcessMemory","int",$PHandle,"int",$PLibRemote+$i,"int*",Asc(StringMid($DllPath,$i+1,1)),"int",1,"int",0)
			If IsArray($Ret) Then
				If $Ret[0] = 0 Then
					SetError(-7)
					Return False
				EndIf
			Else
				SetError(-8)
				Return False
			EndIf
	Next
	$ModHandle = DLLCall($Kernel32,"long","GetModuleHandle","str","kernel32.dll")
	If IsArray($ModHandle) Then
		If $ModHandle[0] > 0 Then
			$ModHandle = $ModHandle[0]
		Else
			SetError(-9)
			Return False
		EndIf
	Else
		SetError(-10)
		Return False
	EndIf
	$LoadLibRarya = DLLCall($Kernel32,"long","GetProcAddress","long",$ModHandle,"str","LoadLibraryA")
	If IsArray($LoadLibRarya) Then
		If $LoadLibRarya[0] > 0 Then
			$LoadLibRarya = $LoadLibRarya[0]
		Else
			SetError(-11)
			Return False
		EndIf
	Else
		SetError(-12)
		Return False
	EndIf
	$HthRead = DLLCall($Kernel32,"int","CreateRemoteThread","int",$PHandle,"int",0,"int",0,"long",$LoadLibRarya,"long",$PLibRemote,"int",0,"int",0)
		If IsArray($HthRead) Then
			If $HthRead[0] > 0 Then
				$HthRead = $HthRead[0]
			Else
				SetError(-13)
				Return
			EndIf
		Else
			SetError(-14)
			Return False
		EndIf
	DLLCall($Kernel32,"int","VirtualFreeEx","int",$PHandle,"int",$PLibRemote,"int",4096,"int",32768)
	DLLCall($Kernel32,"int","CloseHandle","int",$HthRead)
	DLLCall($Kernel32,"int","CloseHandle","int",$PHandle)
	DllClose($Kernel32)
	Return True
EndFunc

Die ist halt für DLLs, aber wie kann ich einen Opcode injecten? Das ist doch ein einfacher String und nicht an einer Datei gebunden o.O

Shadow992 · 10/08/2010, 16:48

Quote:

Originally Posted by pinguin94

Hmm gut, dann brauch ich ne Liste von allen Befehlen und den dazugehörigen Opcodes^^

Die einzige Funktion zum Injecten fällt mir die für DLLs nur ein:

Code:

Func InjectDLL($hWnd,$DllPath)
	If IsHWnd($hWnd) = 0 Then
		SetError(-1)
		Return False
	ElseIf StringLen($DllPath)<= 4 OR Stringright($DllPath, 4) <> ".dll" Then
		SetError(-2)
		Return False
	EndIf
	Local $PID,$PHandle,$PLibRemote,$ModHandle,$LoadLibRarya,$HthRead
	Local $Kernel32 = DllOpen("kernel32.dll")
	If $Kernel32 = -1 Then
		Exit
	EndIf
	$PID = DLLCall("user32.dll","int","GetWindowThreadProcessId","hwnd",$hWnd,"int*",0)
	If IsArray($PID) Then
		$PID=$PID[2]
	Else
		SetError(-3)
		Return False
	EndIf
	$PHandle = DLLCall($Kernel32,"int","OpenProcess","int",2035711,"int",0,"int",$PID)
	If IsArray($PHandle) And $PHandle[0] > 0 Then
		$PHandle = $PHandle[0]
	ELSE
		SetError(-4)
		Return False
	EndIf
	$PLibRemote = DLLCall($Kernel32,"int","VirtualAllocEx","int",$PHandle,"short",0,"int",4096,"int",4096,"int",4)
	If IsArray($PLibRemote) Then
		If $PLibRemote[0] > 0 Then
			$PLibRemote = $PLibRemote[0]
		Else
			SetError(-5)
			Return False
		EndIf
	Else
		SetError(-6)
		Return False
	EndIf
	For $i = 0 To StringLen($DllPath)
		$Ret = DLLCall("kernel32.dll","int","WriteProcessMemory","int",$PHandle,"int",$PLibRemote+$i,"int*",Asc(StringMid($DllPath,$i+1,1)),"int",1,"int",0)
			If IsArray($Ret) Then
				If $Ret[0] = 0 Then
					SetError(-7)
					Return False
				EndIf
			Else
				SetError(-8)
				Return False
			EndIf
	Next
	$ModHandle = DLLCall($Kernel32,"long","GetModuleHandle","str","kernel32.dll")
	If IsArray($ModHandle) Then
		If $ModHandle[0] > 0 Then
			$ModHandle = $ModHandle[0]
		Else
			SetError(-9)
			Return False
		EndIf
	Else
		SetError(-10)
		Return False
	EndIf
	$LoadLibRarya = DLLCall($Kernel32,"long","GetProcAddress","long",$ModHandle,"str","LoadLibraryA")
	If IsArray($LoadLibRarya) Then
		If $LoadLibRarya[0] > 0 Then
			$LoadLibRarya = $LoadLibRarya[0]
		Else
			SetError(-11)
			Return False
		EndIf
	Else
		SetError(-12)
		Return False
	EndIf
	$HthRead = DLLCall($Kernel32,"int","CreateRemoteThread","int",$PHandle,"int",0,"int",0,"long",$LoadLibRarya,"long",$PLibRemote,"int",0,"int",0)
		If IsArray($HthRead) Then
			If $HthRead[0] > 0 Then
				$HthRead = $HthRead[0]
			Else
				SetError(-13)
				Return
			EndIf
		Else
			SetError(-14)
			Return False
		EndIf
	DLLCall($Kernel32,"int","VirtualFreeEx","int",$PHandle,"int",$PLibRemote,"int",4096,"int",32768)
	DLLCall($Kernel32,"int","CloseHandle","int",$HthRead)
	DLLCall($Kernel32,"int","CloseHandle","int",$PHandle)
	DllClose($Kernel32)
	Return True
EndFunc

Die ist halt für DLLs, aber wie kann ich einen Opcode injecten? Das ist doch ein einfacher String und nicht an einer Datei gebunden o.O

Was meinst du was die Dll ist?
Das ist auch nur ein String mit Opcode, aber ich sag dir lass das sein.
Ich bin mal so frech und behaupte ein "reiner AutoItler" wird etwas derartiges nie hinbekommen. Dafür fehlt einfach das tiefere Verständniss.
Was du jedoch machen könntest und was echt intressant ist, ist eine eigene "Sprache" zu machen (natürlich eine Sprache mit Interpret). Ich hatte mich damit auch mal eine Zeit lang beschäftigt und ein Mittelmäßiges Ergebniss (mit C++) erreicht. Aber es ist meiner Meinung nach die beste Art und Weise das ganze nocheinmal zu vertiefen.

Und wie gesagt Bots sind immer gern gesehen und auch relativ schnell gemacht.
Btw. Du brauchst dafür nicht zwingend WinHttp.

Ansonsten wie schoneinmal geschrieben wurde, lerne C/C++.
Mir gings auch so, dass mir AutoIt mit der Zeit etwas zu "langweilig" wurde.
Dann bin ich eine Zeit lang komplett auf C++ umgestiegen und jetzt bin ich mehr in der Mitte. Kleine Sachen mache ich mit AutoIt und große/wichtige Sachen mit C/C++. C/C++ ist, in meinen Augen, eine schöne Sprache mit der man den Ablauf eines Computerprogramms besser zu verstehen lernt.

Nach C/C++ kannste dann mit ASM weitermachen. Viele meinen immer, dass ASM ja so schwer und so unverständlich ist. Das kann ich aber überhaupt nicht sagen. Sicher, ASM ist nicht gerade die beste Sprache für größere Projekte, aber einfache Sachen lassen sich auch mit/in ASM ruck zuck machen. Es dauert nur seine Zeit bis man bei ASM wirklich durchsteigt.

Alles in Allem: Wenn du Langeweile hast, dann lerne etwas Neues.
Leute, die sich langweilen wissen mit ihrer freien Zeit nur nichts anzufangen.

PenGuin :O · 10/08/2010, 17:39

Zur Info: Durch die Schule bin ich gezwungen Assembler zu lernen :P
Wobei halt nicht fürn Pc sondern für einen Microcontroller, wenn man mir das kurz erklärt, kann ich mein Glück versuchen

lolkop · 10/08/2010, 18:56

naja du scheinst die dll funktion nicht selbst erstellt zu haben. alles was du brauchst ist darin bereits verwendet worden.

du reservierst dir halt immer speicherbereiche im target prozess mit virtualallocex. da packst du rein was auch immer du brauchst.

wenn du da deinen asm code reingepackt hast, kannst du den ausführen via createremote thread.

die asm funktionen brauchst du nicht wirklich übersetzen. würde immer direkt mit opcodes arbeiten (find ich persöhnlich einfacher als immer die asm befehle auszuschreiben).
ausserdem wäre es sonst extrem schwer sachen wie calls umzusetzen, da du für einen call immer die position im speicher benötgist. selbes gilt auch für größere jumps etc...

ist im prinziep das selbe wie dllstruct handling. nur ist in diesem falle die dllstruct die du dir erstellst im speicher vom anderen tool.

habe aber gerade gesehn das es ja schon eine funktion gibt, die es ermöglicht autoit funktionen in codecaves zu nutzen =)
die DllCallback funktionen. leider sind die wie auch alle anderen dll funktionen nicht in anderen tools nutzbar. aber man kann ja per DllCallbackGetPtr die startadresse auslesen, und dann per memory funktionen das ganze in den anderen prozess überschreiben =)

Btw:
das hatten wir auch in der schule und ihr arbeitet da doch auch mit pcs... nur halt mit sehr alten und sehr langsamen:P

PenGuin :O · 10/08/2010, 19:01

Ja stimmt^^

Und die Funktion ist nicht von mir, nein.
Also lohnt das Projekt gar nicht, die ganzen asm Befehle in Opcode zu übersetzen?

lolkop · 10/08/2010, 19:12

Quote:

Originally Posted by pinguin94

Ja stimmt^^

Und die Funktion ist nicht von mir, nein.
Also lohnt das Projekt gar nicht, die ganzen asm Befehle in Opcode zu übersetzen?

das hab ich sowieso nicht vorgeschlagen.
gut wären funktionen die man quasi wie die dllstruct funktionen nutzen kann. aber sowas hat sich jeder in 2-3min selbst geschrieben. dafür braucht man keine udf :P (wobei das gleiche auch für die memory funktionen gilt und trotzdem nutzen aus irgend einem grund alle die bekannte udf)

MrSm!th · 10/09/2010, 16:07

das wird etwas schwerer pingu, du bräuchtest nicht nur die liste der opdcodes, sondern müsstest noch die operanden kennen und einbauen können ;O

ist jetzt etwas komisch ausgedrückt :/

für den befehl call ist ein möglicher opcode, der meistens auch genutzt wird, E8
dann brauchst du aber noch 4 Bytes dahinter, die die Differenz zwischen dem Call und dem Ziel darstellen, damit der Prozessor weiß, wohin er soll.

dafür muss man, wie lol schon sagte, die position im speicher kennen, aber das ist doch kein problem

ich meine, wenn man es in opcodes darstellen könnte, geht das auch so.
die funktion würde ja eine codecave suchen und darin den code schreiben.
falls wir von einem jump/call zur codecave sprechen, würde man das so realisieren, dass man die adresse der codecave minus die adresse, an der man den call hinschreiben will rechnet und schon weiß man, was hinter das E8 muss.

ich fände es bequehmer, die commands anzugeben, als alles selbst umzurechnen ;O

und opcodes injecten wäre sehr einfach :>, du machst die codecave und schreibst die fertigen opcodes per WriteProcessMemory darein.

aber das war sowieso fies

, da brauchste mehrere tabellen, die obcode mit befehl verknüpfen, da es extrem viele obcodes gibt.

war ne art wunschdenken, eine art runtime assembler eingebaut in autoit

@lolkop: wenn du es selbst umrechnest, hast du zufällig ne art runtime assembler?

ich finde es zu umständlich, sowas zb. in olly einzugeben oder gar nen assembler zu nutzen und das ergebnis dann im hex editor ansehen zu müssen ;<

lolkop · 10/09/2010, 16:52

Quote:

Originally Posted by MrSm!th

das wird etwas schwerer pingu, du bräuchtest nicht nur die liste der opdcodes, sondern müsstest noch die operanden kennen und einbauen können ;O

ist jetzt etwas komisch ausgedrückt :/

für den befehl call ist ein möglicher opcode, der meistens auch genutzt wird, E8
dann brauchst du aber noch 4 Bytes dahinter, die die Differenz zwischen dem Call und dem Ziel darstellen, damit der Prozessor weiß, wohin er soll.

dafür muss man, wie lol schon sagte, die position im speicher kennen, aber das ist doch kein problem
ich meine, wenn man es in opcodes darstellen könnte, geht das auch so.
die funktion würde ja eine codecave suchen und darin den code schreiben.
falls wir von einem jump/call zur codecave sprechen, würde man das so realisieren, dass man die adresse der codecave minus die adresse, an der man den call hinschreiben will rechnet und schon weiß man, was hinter das E8 muss.

ich fände es bequehmer, die commands anzugeben, als alles selbst umzurechnen ;O

und opcodes injecten wäre sehr einfach :>, du machst die codecave und schreibst die fertigen opcodes per WriteProcessMemory darein.

aber das war sowieso fies , da brauchste mehrere tabellen, die obcode mit befehl verknüpfen, da es extrem viele obcodes gibt.

war ne art wunschdenken, eine art runtime assembler eingebaut in autoit

@lolkop: wenn du es selbst umrechnest, hast du zufällig ne art runtime assembler? ich finde es zu umständlich, sowas zb. in olly einzugeben oder gar nen assembler zu nutzen und das ergebnis dann im hex editor ansehen zu müssen ;<

naja das problem bei calls ist ja, dass du nicht nur die adresse, die du von virtualallocex bekommst brauchst, sondern auchnoch die bisherige opcode länge mit einrechnen musst.

das ganze wäre als externe funktion nur wirklich gut umsetzbar, wenn man entweder die aktuelle opcodelänge und die startadresse global setzt (was aber beim nutzen mehrerer solcher speicherbereiche zu problemen führen wird), oder indem man diese sachen als parameter einbaut. allerdings macht es wie bereits gesagt dann keinen sinn noch eine extra call funktion zu schreiben.

hier mal als beispiel eine meiner funktionen für perfect world:

Code:

Func SelectMob($id)
	Local $thread, $buffer, $loop, $result, $OPcode
	; --- save the position of the allocated memory ---
	$alloc = DllCall($kernel32, 'int', 'VirtualAllocEx', 'int', $mid, 'ptr', 0, 'int', 0x46, 'int', 0x1000, 'int', 0x40)
	; --- build up the asm code ---
	; 0046061D  A1 6C3E9F00       MOV EAX,DWORD PTR DS:[9F3E6C]
	; 00460622  57                PUSH EDI                        <---- EDI Contains Mob-ID
	; 00460623  8B48 20           MOV ECX,DWORD PTR DS:[EAX+20]
	; 00460626  81C1 EC000000     ADD ECX,0EC
	; 0046062C  E8 8F961800       CALL elementc.005E9CC0
	$OPcode &= '60'                                                           ; pushad
	$OPcode &= 'A1'&_hex($base)                                               ; mov eax, [base]
	$OPcode &= '68'&_hex($id)                                                 ; push mob-id
	$OPcode &= '8B4820'                                                       ; mov ecx, [eax+0x20]
	$OPcode &= '81C1'&_hex(0xEC)                                              ; add ecx, 0xEC
	$OPcode &= 'E8'&_hex($select_call-$alloc[0]-5-StringLen($OPcode)/2)       ; call select_call
	$OPcode &= '61'                                                           ; popad
	$OPcode &= 'C3'                                                           ; retn
	; --- enter the asm code to to a dllstruct, which can be used with WriteProcessMemory ---
	$buffer = DllStructCreate('byte[' & StringLen($OPcode) / 2 & ']')
	For $loop = 1 To DllStructGetSize($buffer)
		DllStructSetData($buffer, 1, Dec(StringMid($OPcode, ($loop - 1) * 2 + 1, 2)), $loop)
	Next
	; --- now letz write the code from our dllstruct ---
	DllCall($kernel32, 'int', 'WriteProcessMemory', 'int', $mid, 'int', $alloc[0], 'int', DllStructGetPtr($buffer), 'int', DllStructGetSize($buffer), 'int', 0)
	; --- now we run the asm code we've just written ---
	$thread = DllCall($kernel32, 'int', 'CreateRemoteThread', 'int', $mid, 'int', 0, 'int', 0, 'int', $alloc[0], 'ptr', 0, 'int', 0, 'int', 0)
	; --- wait till the thread did his job ---
	Do
		$result = DllCall('kernel32.dll', 'int', 'WaitForSingleObject', 'int', $thread[0], 'int', 50)
	Until $result[0] <> 258
	; --- close everything we've opened ---
	DllCall($kernel32, 'int', 'CloseHandle', 'int', $thread[0])
	DllCall($kernel32, 'ptr', 'VirtualFreeEx', 'hwnd', $mid, 'int', $alloc[0], 'int', 0, 'int', 0x8000)
EndFunc

wie man sieht ist der call hier so aufgebaut:

Code:

'E8'&_hex($select_call-$alloc[0]-5-StringLen($OPcode)/2)

meiner meinung nach wäre der versuch eine externe funktion zu erstellen absolut nutzlos, da man die benötigten werte als parameter übergeben müsste... dann doch lieber gleich mit das ganze als opcode aufschreiben :P

PenGuin :O · 10/09/2010, 17:42

Code:

; --- enter the asm code to to a dllstruct, which can be used with WriteProcessMemory ---
	$buffer = DllStructCreate('byte[' & StringLen($OPcode) / 2 & ']')
	For $loop = 1 To DllStructGetSize($buffer)
		DllStructSetData($buffer, 1, Dec(StringMid($OPcode, ($loop - 1) * 2 + 1, 2)), $loop)
	Next
	; --- now letz write the code from our dllstruct ---
	DllCall($kernel32, 'int', 'WriteProcessMemory', 'int', $mid, 'int', $alloc[0], 'int', DllStructGetPtr($buffer), 'int', DllStructGetSize($buffer), 'int', 0)
	; --- now we run the asm code we've just written ---
	$thread = DllCall($kernel32, 'int', 'CreateRemoteThread', 'int', $mid, 'int', 0, 'int', 0, 'int', $alloc[0], 'ptr', 0, 'int', 0, 'int', 0)
	; --- wait till the thread did his job ---
	Do
		$result = DllCall('kernel32.dll', 'int', 'WaitForSingleObject', 'int', $thread[0], 'int', 50)
	Until $result[0] <> 258
	; --- close everything we've opened ---
	DllCall($kernel32, 'int', 'CloseHandle', 'int', $thread[0])
	DllCall($kernel32, 'ptr', 'VirtualFreeEx', 'hwnd', $mid, 'int', $alloc[0], 'int', 0, 'int', 0x8000)

Dieser Teil ist zum laden des Opcodes in den Process?
Wenn ja bräuchte man ja letztendlich nur noch alle Opcodes der Asm Befehle und dann halt deren Parameter...

Ich probier mein Glück

Wo hast du die Variable $mid, bzw. was steht da drin?

lolkop · 10/09/2010, 17:48

Quote:

Originally Posted by pinguin94

Code:

; --- enter the asm code to to a dllstruct, which can be used with WriteProcessMemory ---
	$buffer = DllStructCreate('byte[' & StringLen($OPcode) / 2 & ']')
	For $loop = 1 To DllStructGetSize($buffer)
		DllStructSetData($buffer, 1, Dec(StringMid($OPcode, ($loop - 1) * 2 + 1, 2)), $loop)
	Next
	; --- now letz write the code from our dllstruct ---
	DllCall($kernel32, 'int', 'WriteProcessMemory', 'int', $mid, 'int', $alloc[0], 'int', DllStructGetPtr($buffer), 'int', DllStructGetSize($buffer), 'int', 0)
	; --- now we run the asm code we've just written ---
	$thread = DllCall($kernel32, 'int', 'CreateRemoteThread', 'int', $mid, 'int', 0, 'int', 0, 'int', $alloc[0], 'ptr', 0, 'int', 0, 'int', 0)
	; --- wait till the thread did his job ---
	Do
		$result = DllCall('kernel32.dll', 'int', 'WaitForSingleObject', 'int', $thread[0], 'int', 50)
	Until $result[0] <> 258
	; --- close everything we've opened ---
	DllCall($kernel32, 'int', 'CloseHandle', 'int', $thread[0])
	DllCall($kernel32, 'ptr', 'VirtualFreeEx', 'hwnd', $mid, 'int', $alloc[0], 'int', 0, 'int', 0x8000)

Dieser Teil ist zum laden des Opcodes in den Process?
Wenn ja bräuchte man ja letztendlich nur noch alle Opcodes der Asm Befehle und dann halt deren Parameter...

Ich probier mein Glück

-.- ich hab doch gerade erklärt wieso sowas nutzlos ist...
und nein das hat nichts mit laden von opcodes im prozess zu tun. man gibt sich halt speicher frei, schreibt da seinen asm code rein und startet das ganze dann per remote thread funktion. nur braucht man zum erstellen des asm codes schonmal mindestens die adresse vom freigegebenen speicherbereich.