Register for your free account! | Forgot your password?

Go Back   elitepvpers > MMORPGs > Guild Wars > GW Bots
You last visited: Today at 03:00

  • Please register to post and access all features, it's quick, easy and FREE!

Advertisement



Au3 und Assembler?

Discussion on Au3 und Assembler? within the GW Bots forum part of the Guild Wars category.

Reply
 
Old   #1
 
elite*gold: 0
Join Date: Aug 2006
Posts: 515
Received Thanks: 96
Au3 und Assembler?

Hi, ich frage mich ob man Autoit mit Assembler verbinden kann, also inlineassembler betreiben kann? Weis villeicht jemand wie das gehen könnte?
Jacob_G is offline  
Old 01/03/2009, 16:12   #2
 
elite*gold: 0
Join Date: Nov 2008
Posts: 576
Received Thanks: 191
ich kenn nur das
asm.au3
Code:
#include-once

Func CopyMemory($Destination, $Source, $Length)
    Local $Return
    $Return = DllCall("kernel32.dll", "none", "RtlMoveMemory", "ptr", $Destination, "ptr", $Source,"int", $Length)
    Return $Return[0]
EndFunc   ;==>CopyMemory
Func GetWindowThreadProcessId($hWnd, $lpdwProcessId)
    Local $Return
    $Return = DllCall("user32.dll", "int", "GetWindowThreadProcessId", "int", $hWnd, "int", $lpdwProcessId)
    Return $Return[0]
EndFunc   ;==>GetWindowThreadProcessId
Func CreateRemoteThread($hProcess, $lpThreadAttributes, $dwStackSize, $lpStartAddress, $lpParameter, $dwCreationFlags, $lpThreadId)
    Local $Return
    $Return = DllCall("kernel32.dll", "int", "CreateRemoteThread", "int", $hProcess, "ptr", $lpThreadAttributes, "int", $dwStackSize, "int", $lpStartAddress, "ptr", $lpParameter, "int", $dwCreationFlags, "int", $lpThreadId)
    Return $Return[0]
EndFunc   ;==>CreateRemoteThread

Func WriteProcessMemory($hProcess, $lpBaseAddress, $lpBuffer, $nSize, $lpNumberOfBytesWritten)
    Global $Return
    $Return = DllCall ("kernel32.dll", "int", "WriteProcessMemory", "int", $hProcess, "ptr", $lpBaseAddress, "ptr", $lpBuffer, "int", $nSize,"int", $lpNumberOfBytesWritten)
    Return $Return[0]
EndFunc

Func CallWindowProc($lpPrevWndFunc, $hWnd, $Msg, $wParam, $lParam)
    Local $Return
    $Return = DllCall("user32.dll", "int", "CallWindowProcA", "int", $lpPrevWndFunc, "int", $hWnd, "int", $Msg, "int", $wParam, "int", $lParam)
    Return $Return[0]
EndFunc   ;==>CallWindowProc

Func VirtualAllocEx($hProcess, $pAddress, $iSize, $iAllocation, $iProtect)
    Local $aResult = DllCall("Kernel32.dll", "ptr", "VirtualAllocEx", "int", $hProcess, "ptr", $pAddress, "int", $iSize, "int", $iAllocation, "int", $iProtect)
    If @error Or Not IsArray($aResult) Then Return SetError(-1, -1, 0)
    Return $aResult[0]
EndFunc   ;==>VirtualAllocEx

Func VirtualFreeEx($hProcess, $pAddress, $iSize, $iFreeType)
    Local $aResult = DllCall("Kernel32.dll", "ptr", "VirtualFreeEx", "hwnd", $hProcess, "ptr", $pAddress, "int", $iSize, "int", $iFreeType)
    If @error Or Not IsArray($aResult) Then Return SetError(-1, -1, 0)
    Return $aResult[0]
EndFunc   ;==>VirtualFreeEx

Func WaitForSingleObject($hHandle, $dwMilliseconds)
    Local $Return
    $Return = DllCall("kernel32.dll", "int", "WaitForSingleObject", "int", $hHandle, "int", $dwMilliseconds)
    Return $Return[0]
EndFunc   ;==>WaitForSingleObject

Func OpenProcess($iAccess, $bInherit, $iProcessID)
    Local $aResult = DllCall("Kernel32.Dll", "int", "OpenProcess", "int", $iAccess, "int", $bInherit, "int", $iProcessID)
    If @error Or Not IsArray($aResult) Then Return SetError(-1, -1, 0)
    Return $aResult[0]
EndFunc   ;==>OpenProcess

Func CloseHandle($hObject)
    Local $aResult = DllCall("Kernel32.dll", "int", "CloseHandle", "int", $hObject)
    If @error Or Not IsArray($aResult) Then Return SetError(-1, -1, 0)
    Return $aResult[0]
EndFunc   ;==>CloseHandle

;===============================================================================
;~ Private Declare Function GetAddrOf Lib "KERNEL32" Alias "MulDiv" (nNumber As Any, Optional ByVal nNumerator As Long = 1, Optional ByVal nDenominator As Long = 1) As Long
;~    ' This is the dummy function used to get the addres of a VB variable.
Func VarPtr($v_Variable)    ;VarPtr
;~     Declare Function VarPtrArray Lib "msvbvm60.dll" Alias "VarPtr" _
;~ (Var() as Any) As Long
    Local $pointer ,$debug = True
    $pointer = DllCall("KERNEL32.dll", "long", "MulDiv", "ptr", $v_Variable[0])
    ;$pointer =dllcall("msvbvm60.dll","long","VarPtr","long",$v_Variable[0])
    If @error Then
        If $debug Then MsgBox(0, "Error:", "Error:>" & @error & @CRLF)
        Return 0
    Else
        Return $pointer
    EndIf

EndFunc   ;==>VarPtr
;=====================================================================================
;===============================================================================
Const $PAGE_EXECUTE_READWRITE = 0x40
Const $MEM_COMMIT = 0x1000
Const $MEM_RELEASE = 0x8000
Const $MEM_DECOMMIT = 0x4000
Const $PROCESS_ALL_ACCESS = 0x1F0FFF
Const $INFINITE = 0xFFFF      ;  Infinite timeout
Const $WAIT_TIMEOUT = 0x102
Dim $AsmCode[100]
Dim $OPcode
Dim $InjectProcess               ;??????ID
Dim $tmp_Addr                   ;??????????
Dim $RThwnd                      ;?????????
;===============================================================================

Func Get_Result()
    Dim $i
    ReDim $AsmCode [StringLen($OPcode) / 2 - 1]
    For $i = 0 To UBound($AsmCode)
        $AsmCode[$i] = Int("0x" & StringMid($OPcode, $i * 2 + 1, 2))
    Next
    $Get_Result = CallWindowProc(VarPtr($AsmCode[0]), 0, 0, 0, 0)
EndFunc   ;==>Get_Result

Func Get_Code()
    $Get_Code = $OPcode
EndFunc   ;==>Get_Code
;================================
Func Run_ASM2($hWnd)
    Dim $i, $tmp_Addr, $RThwnd, $h, $pid
    ReDim $AsmCode [StringLen ($OPcode) / 2 - 1]
    For $i = 0 To UBound($AsmCode)
        $AsmCode [$i] = Int("0x" & StringMid($OPcode, $i * 2 + 1, 2))
    Next
    GetWindowThreadProcessId($hWnd, $pid)
    $h = OpenProcess($PROCESS_ALL_ACCESS, False, $pid)
    $tmp_Addr = VirtualAllocEx($h, 0, UBound($AsmCode) + 1, $MEM_COMMIT, $PAGE_EXECUTE_READWRITE)
    WriteProcessMemory($h, $tmp_Addr, VarPtr($AsmCode[0]), UBound($AsmCode) + 1, 0)
    $RThwnd = CreateRemoteThread($h, 0, 0, $tmp_Addr, 0, 0, 0)
    VirtualFreeEx($h, $tmp_Addr, UBound($AsmCode) + 1, $MEM_RELEASE)
    CloseHandle($RThwnd)
    CloseHandle($h)
    $OPcode = ""
EndFunc   ;==>Run_ASM2
;=================================
Func InjectCode($hWnd)
    Dim $i, $h, $pid
    ReDim $AsmCode [StringLen($OPcode) / 2 - 1]
    For $i = 0 To UBound($AsmCode)
        $AsmCode[$i] = Int("0x" & StringMid($OPcode, $i * 2 + 1, 2))
    Next
    GetWindowThreadProcessId($hWnd, $pid)                                                ;????ID
    $InjectProcess = OpenProcess($PROCESS_ALL_ACCESS, False, $pid)                         ;???????????
    $tmp_Addr = VirtualAllocEx($InjectProcess, 0, UBound($AsmCode) + 1, _
            $MEM_COMMIT, $PAGE_EXECUTE_READWRITE)                       ;?????????
    WriteProcessMemory($InjectProcess, $tmp_Addr, VarPtr($AsmCode[0]), _
            UBound($AsmCode) + 1, 0)                                  ;?????????
EndFunc   ;==>InjectCode

Func Run_ASM()                                                                           ;?????????
    Dim $Ret
    $RThwnd = CreateRemoteThread($InjectProcess, 0, 0, $tmp_Addr, 0, 0, 0)
    Do
        $Ret = WaitForSingleObject($RThwnd, 50)                   ;??50??
        ;DoEvents
    Until $Ret <> $WAIT_TIMEOUT
    CloseHandle($RThwnd)
EndFunc   ;==>Run_ASM

Func FreeMem()
    VirtualFreeEx($InjectProcess, $tmp_Addr, UBound($AsmCode) + 1, $MEM_RELEASE)
    CloseHandle($InjectProcess)
    $OPcode = ""
    $AsmCode = 0
EndFunc   ;==>FreeMem
;========================================================
Func Int2Hex($Value, $n)  ;?????
    Dim $tmp1, $tmp2, $i
    $tmp1 = StringRight("0000000" + Hex($Value), $n)
    For $i = 0 To StringLen($tmp1) / 2 - 1
        $tmp2 = $tmp2 + StringMid($tmp1, StringLen($tmp1) - 1 - 2 * $i, 2)
    Next
    $Int2Hex = $tmp2
EndFunc   ;==>Int2Hex

Func Leave()
    $OPcode = $OPcode + "C9"
EndFunc   ;==>Leave

Func Pushad()
    $OPcode = $OPcode + "60"
EndFunc   ;==>Pushad

Func Popad()
    $OPcode = $OPcode + "61"
EndFunc   ;==>Popad

Func Nop()
    $OPcode = $OPcode + "90"
EndFunc   ;==>Nop

Func Ret()
    $OPcode = $OPcode + "C3"
EndFunc   ;==>Ret

Func RetA($i)
    $OPcode = $OPcode + Int2Hex($i, 4)
EndFunc   ;==>RetA

Func IN_AL_DX()
    $OPcode = $OPcode + "EC"
EndFunc   ;==>IN_AL_DX

Func TEST_EAX_EAX()
    $OPcode = $OPcode + "85C0"
EndFunc   ;==>TEST_EAX_EAX

;Add
;+++++++++++++++++++++++++++++++++++
Func Add_EAX_EDX()
    $OPcode = $OPcode + "03C2"
EndFunc   ;==>Add_EAX_EDX

Func Add_EBX_EAX()
    $OPcode = $OPcode + "03D8"
EndFunc   ;==>Add_EBX_EAX

Func Add_EAX_DWORD_Ptr($i)
    $OPcode = $OPcode + "0305" + Int2Hex($i, 8)
EndFunc   ;==>Add_EAX_DWORD_Ptr

Func Add_EBX_DWORD_Ptr($i)
    $OPcode = $OPcode + "031D" + Int2Hex($i, 8)
EndFunc   ;==>Add_EBX_DWORD_Ptr

Func Add_EBP_DWORD_Ptr($i)
    $OPcode = $OPcode + "032D" + Int2Hex($i, 8)
EndFunc   ;==>Add_EBP_DWORD_Ptr

Func Add_EAX($i)
    $OPcode = $OPcode + "05" + Int2Hex($i, 8)
EndFunc   ;==>Add_EAX

Func Add_EBX($i)
    $OPcode = $OPcode + "83C3" + Int2Hex($i, 8)
EndFunc   ;==>Add_EBX

Func Add_ECX($i)
    $OPcode = $OPcode + "83C1" + Int2Hex($i, 8)
EndFunc   ;==>Add_ECX

Func Add_EDX($i)
    $OPcode = $OPcode + "83C2" + Int2Hex($i, 8)
EndFunc   ;==>Add_EDX

Func Add_ESI($i)
    $OPcode = $OPcode + "83C6" + Int2Hex($i, 8)
EndFunc   ;==>Add_ESI

Func Add_ESP($i)
    $OPcode = $OPcode + "83C4" + Int2Hex($i, 8)
EndFunc   ;==>Add_ESP

;Call
;+++++++++++++++++++++++++++++++++++
Func Call_EAX()
    $OPcode = $OPcode + "FFD0"
EndFunc   ;==>Call_EAX

Func Call_EBX()
    $OPcode = $OPcode + "FFD3"
EndFunc   ;==>Call_EBX

Func Call_ECX()
    $OPcode = $OPcode + "FFD1"
EndFunc   ;==>Call_ECX

Func Call_EDX()
    $OPcode = $OPcode + "FFD2"
EndFunc   ;==>Call_EDX

Func Call_ESI()
    $OPcode = $OPcode + "FFD2"
EndFunc   ;==>Call_ESI

Func Call_ESP()
    $OPcode = $OPcode + "FFD4"
EndFunc   ;==>Call_ESP

Func Call_EBP()
    $OPcode = $OPcode + "FFD5"
EndFunc   ;==>Call_EBP

Func Call_EDI()
    $OPcode = $OPcode + "FFD7"
EndFunc   ;==>Call_EDI

Func Call_DWORD_Ptr($i)
    $OPcode = $OPcode + "FF15" + Int2Hex($i, 8)
EndFunc   ;==>Call_DWORD_Ptr

Func Call_DWORD_Ptr_EAX()
    $OPcode = $OPcode + "FF10"
EndFunc   ;==>Call_DWORD_Ptr_EAX

Func Call_DWORD_Ptr_EBX()
    $OPcode = $OPcode + "FF13"
EndFunc   ;==>Call_DWORD_Ptr_EBX

;Cmp
;+++++++++++++++++++++++++++++++++++
Func Cmp_EAX($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "83F8" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "3D" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Cmp_EAX

Func Cmp_EAX_EDX()
    $OPcode = $OPcode + "3BC2"
EndFunc   ;==>Cmp_EAX_EDX

Func Cmp_EAX_DWORD_Ptr($i)
    $OPcode = $OPcode + "3B05" + Int2Hex($i, 8)
EndFunc   ;==>Cmp_EAX_DWORD_Ptr

Func Cmp_DWORD_Ptr_EAX($i)
    $OPcode = $OPcode + "3905" + Int2Hex($i, 8)
EndFunc   ;==>Cmp_DWORD_Ptr_EAX

;DEC
;+++++++++++++++++++++++++++++++++++
Func Dec_EAX()
    $OPcode = $OPcode + "48"
EndFunc   ;==>Dec_EAX

Func Dec_EBX()
    $OPcode = $OPcode + "4B"
EndFunc   ;==>Dec_EBX

Func Dec_ECX()
    $OPcode = $OPcode + "49"
EndFunc   ;==>Dec_ECX

Func Dec_EDX()
    $OPcode = $OPcode + "4A"
EndFunc   ;==>Dec_EDX

;Idiv
;+++++++++++++++++++++++++++++++++++
Func Idiv_EAX()
    $OPcode = $OPcode + "F7F8"
EndFunc   ;==>Idiv_EAX

Func Idiv_EBX()
    $OPcode = $OPcode + "F7FB"
EndFunc   ;==>Idiv_EBX

Func Idiv_ECX()
    $OPcode = $OPcode + "F7F9"
EndFunc   ;==>Idiv_ECX

Func Idiv_EDX()
    $OPcode = $OPcode + "F7FA"
EndFunc   ;==>Idiv_EDX

;Imul
;+++++++++++++++++++++++++++++++++++
Func Imul_EAX_EDX()
    $OPcode = $OPcode + "0FAFC2"
EndFunc   ;==>Imul_EAX_EDX

Func Imul_EAX($i)
    $OPcode = $OPcode + "6BC0" + Int2Hex($i, 2)
EndFunc   ;==>Imul_EAX

Func ImulB_EAX($i)
    $OPcode = $OPcode + "69C0" + Int2Hex($i, 8)
EndFunc   ;==>ImulB_EAX

;INC
;+++++++++++++++++++++++++++++++++++
Func Inc_EAX()
    $OPcode = $OPcode + "40"
EndFunc   ;==>Inc_EAX

Func Inc_EBX()
    $OPcode = $OPcode + "43"
EndFunc   ;==>Inc_EBX

Func Inc_ECX()
    $OPcode = $OPcode + "41"
EndFunc   ;==>Inc_ECX

Func Inc_EDX()
    $OPcode = $OPcode + "42"
EndFunc   ;==>Inc_EDX

Func Inc_EDI()
    $OPcode = $OPcode + "47"
EndFunc   ;==>Inc_EDI

Func Inc_ESI()
    $OPcode = $OPcode + "46"
EndFunc   ;==>Inc_ESI

Func Inc_DWORD_Ptr_EAX()
    $OPcode = $OPcode + "FF00"
EndFunc   ;==>Inc_DWORD_Ptr_EAX

Func Inc_DWORD_Ptr_EBX()
    $OPcode = $OPcode + "FF03"
EndFunc   ;==>Inc_DWORD_Ptr_EBX

Func Inc_DWORD_Ptr_ECX()
    $OPcode = $OPcode + "FF01"
EndFunc   ;==>Inc_DWORD_Ptr_ECX

Func Inc_DWORD_Ptr_EDX()
    $OPcode = $OPcode + "FF02"
EndFunc   ;==>Inc_DWORD_Ptr_EDX

;JMP/JE/JNE
;+++++++++++++++++++++++++++++++++++
Func JMP_EAX()
    $OPcode = $OPcode + "FFE0"
EndFunc   ;==>JMP_EAX

;Mov
Func Mov_DWORD_Ptr_EAX($i)
    $OPcode = $OPcode + "A3" + Int2Hex($i, 8)
EndFunc   ;==>Mov_DWORD_Ptr_EAX

Func Mov_EAX($i)
    $OPcode = $OPcode + "B8" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EAX

Func Mov_EBX($i)
    $OPcode = $OPcode + "BB" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EBX

Func Mov_ECX($i)
    $OPcode = $OPcode + "B9" + Int2Hex($i, 8)
EndFunc   ;==>Mov_ECX

Func Mov_EDX($i)
    $OPcode = $OPcode + "BA" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EDX

Func Mov_ESI($i)
    $OPcode = $OPcode + "BE" + Int2Hex($i, 8)
EndFunc   ;==>Mov_ESI

Func Mov_ESP($i)
    $OPcode = $OPcode + "BC" + Int2Hex($i, 8)
EndFunc   ;==>Mov_ESP

Func Mov_EBP($i)
    $OPcode = $OPcode + "BD" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EBP


Func Mov_EDI($i)
    $OPcode = $OPcode + "BF" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EDI

Func Mov_EBX_DWORD_Ptr($i)
    $OPcode = $OPcode + "8B1D" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EBX_DWORD_Ptr

Func Mov_ECX_DWORD_Ptr($i)
    $OPcode = $OPcode + "8B0D" + Int2Hex($i, 8)
EndFunc   ;==>Mov_ECX_DWORD_Ptr

Func Mov_EAX_DWORD_Ptr($i)
    $OPcode = $OPcode + "A1" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EAX_DWORD_Ptr

Func Mov_EDX_DWORD_Ptr($i)
    $OPcode = $OPcode + "8B15" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EDX_DWORD_Ptr

Func Mov_ESI_DWORD_Ptr($i)
    $OPcode = $OPcode + "8B35" + Int2Hex($i, 8)
EndFunc   ;==>Mov_ESI_DWORD_Ptr

Func Mov_ESP_DWORD_Ptr($i)
    $OPcode = $OPcode + "8B25" + Int2Hex($i, 8)
EndFunc   ;==>Mov_ESP_DWORD_Ptr

Func Mov_EBP_DWORD_Ptr($i)
    $OPcode = $OPcode + "8B2D" + Int2Hex($i, 8)
EndFunc   ;==>Mov_EBP_DWORD_Ptr

Func Mov_EAX_DWORD_Ptr_EAX()
    $OPcode = $OPcode + "8B00"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EAX

Func Mov_EAX_DWORD_Ptr_EBP()
    $OPcode = $OPcode + "8B4500"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EBP

Func Mov_EAX_DWORD_Ptr_EBX()
    $OPcode = $OPcode + "8B03"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EBX

Func Mov_EAX_DWORD_Ptr_ECX()
    $OPcode = $OPcode + "8B01"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_ECX

Func Mov_EAX_DWORD_Ptr_EDX()
    $OPcode = $OPcode + "8B02"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EDX

Func Mov_EAX_DWORD_Ptr_EDI()
    $OPcode = $OPcode + "8B07"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EDI

Func Mov_EAX_DWORD_Ptr_ESP()
    $OPcode = $OPcode + "8B0424"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_ESP

Func Mov_EAX_DWORD_Ptr_ESI()
    $OPcode = $OPcode + "8B06"
EndFunc   ;==>Mov_EAX_DWORD_Ptr_ESI

Func Mov_EAX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B40" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B80" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EAX_Add

Func Mov_EAX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4424" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8424" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_ESP_Add

Func Mov_EAX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B43" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B83" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EBX_Add

Func Mov_EAX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B41" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B81" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_ECX_Add

Func Mov_EAX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B42" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B82" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EDX_Add

Func Mov_EAX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B47" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B87" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EDI_Add

Func Mov_EAX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B45" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B85" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_EBP_Add

Func Mov_EAX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B46" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B86" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EAX_DWORD_Ptr_ESI_Add

Func Mov_EBX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B58" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B98" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EAX_Add

Func Mov_EBX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5C24" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9C24" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_ESP_Add

Func Mov_EBX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5B" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9B" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EBX_Add

Func Mov_EBX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B59" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B99" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_ECX_Add

Func Mov_EBX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5A" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9A" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EDX_Add

Func Mov_EBX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5F" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9F" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EDI_Add

Func Mov_EBX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5D" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9D" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EBP_Add

Func Mov_EBX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5E" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9E" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EBX_DWORD_Ptr_ESI_Add

Func Mov_ECX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B48" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B88" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EAX_Add

Func Mov_ECX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4C24" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8C24" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_ESP_Add

Func Mov_ECX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4B" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8B" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EBX_Add

Func Mov_ECX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B49" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B89" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_ECX_Add

Func Mov_ECX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4A" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8A" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EDX_Add

Func Mov_ECX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4F" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8F" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EDI_Add

Func Mov_ECX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4D" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8D" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EBP_Add

Func Mov_ECX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B4E" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B8E" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_ECX_DWORD_Ptr_ESI_Add

Func Mov_EDX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B50" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B90" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EAX_Add

Func Mov_EDX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B5424" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B9424" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_ESP_Add

Func Mov_EDX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B53" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B93" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EBX_Add

Func Mov_EDX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B51" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B91" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_ECX_Add

Func Mov_EDX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B52" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B92" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EDX_Add

Func Mov_EDX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B57" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B97" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EDI_Add

Func Mov_EDX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B55" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B95" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EBP_Add

Func Mov_EDX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8B56" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8B96" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Mov_EDX_DWORD_Ptr_ESI_Add

Func Mov_EBX_DWORD_Ptr_EAX()
    $OPcode = $OPcode + "8B18"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EAX

Func Mov_EBX_DWORD_Ptr_EBP()
    $OPcode = $OPcode + "8B5D00"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EBP

Func Mov_EBX_DWORD_Ptr_EBX()
    $OPcode = $OPcode + "8B1B"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EBX

Func Mov_EBX_DWORD_Ptr_ECX()
    $OPcode = $OPcode + "8B19"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_ECX

Func Mov_EBX_DWORD_Ptr_EDX()
    $OPcode = $OPcode + "8B1A"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EDX

Func Mov_EBX_DWORD_Ptr_EDI()
    $OPcode = $OPcode + "8B1F"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_EDI

Func Mov_EBX_DWORD_Ptr_ESP()
    $OPcode = $OPcode + "8B1C24"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_ESP

Func Mov_EBX_DWORD_Ptr_ESI()
    $OPcode = $OPcode + "8B1E"
EndFunc   ;==>Mov_EBX_DWORD_Ptr_ESI
Func Mov_ECX_DWORD_Ptr_EAX()
    $OPcode = $OPcode + "8B08"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EAX

Func Mov_ECX_DWORD_Ptr_EBP()
    $OPcode = $OPcode + "8B4D00"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EBP

Func Mov_ECX_DWORD_Ptr_EBX()
    $OPcode = $OPcode + "8B0B"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EBX

Func Mov_ECX_DWORD_Ptr_ECX()
    $OPcode = $OPcode + "8B09"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_ECX

Func Mov_ECX_DWORD_Ptr_EDX()
    $OPcode = $OPcode + "8B0A"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EDX

Func Mov_ECX_DWORD_Ptr_EDI()
    $OPcode = $OPcode + "8B0F"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_EDI

Func Mov_ECX_DWORD_Ptr_ESP()
    $OPcode = $OPcode + "8B0C24"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_ESP

Func Mov_ECX_DWORD_Ptr_ESI()
    $OPcode = $OPcode + "8B0E"
EndFunc   ;==>Mov_ECX_DWORD_Ptr_ESI

Func Mov_EDX_DWORD_Ptr_EAX()
    $OPcode = $OPcode + "8B10"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EAX

Func Mov_EDX_DWORD_Ptr_EBP()
    $OPcode = $OPcode + "8B5500"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EBP

Func Mov_EDX_DWORD_Ptr_EBX()
    $OPcode = $OPcode + "8B13"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EBX

Func Mov_EDX_DWORD_Ptr_ECX()
    $OPcode = $OPcode + "8B11"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_ECX

Func Mov_EDX_DWORD_Ptr_EDX()
    $OPcode = $OPcode + "8B12"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EDX

Func Mov_EDX_DWORD_Ptr_EDI()
    $OPcode = $OPcode + "8B17"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_EDI

Func Mov_EDX_DWORD_Ptr_ESI()
    $OPcode = $OPcode + "8B16"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_ESI

Func Mov_EDX_DWORD_Ptr_ESP()
    $OPcode = $OPcode + "8B1424"
EndFunc   ;==>Mov_EDX_DWORD_Ptr_ESP

Func Mov_EAX_EBP()
    $OPcode = $OPcode + "8BC5"
EndFunc   ;==>Mov_EAX_EBP

Func Mov_EAX_EBX()
    $OPcode = $OPcode + "8BC3"
EndFunc   ;==>Mov_EAX_EBX

Func Mov_EAX_ECX()
    $OPcode = $OPcode + "8BC1"
EndFunc   ;==>Mov_EAX_ECX

Func Mov_EAX_EDI()
    $OPcode = $OPcode + "8BC7"
EndFunc   ;==>Mov_EAX_EDI

Func Mov_EAX_EDX()
    $OPcode = $OPcode + "8BC2"
EndFunc   ;==>Mov_EAX_EDX

Func Mov_EAX_ESI()
    $OPcode = $OPcode + "8BC6"
EndFunc   ;==>Mov_EAX_ESI

Func Mov_EAX_ESP()
    $OPcode = $OPcode + "8BC4"
EndFunc   ;==>Mov_EAX_ESP

Func Mov_EBX_EBP()
    $OPcode = $OPcode + "8BDD"
EndFunc   ;==>Mov_EBX_EBP

Func Mov_EBX_EAX()
    $OPcode = $OPcode + "8BD8"
EndFunc   ;==>Mov_EBX_EAX

Func Mov_EBX_ECX()
    $OPcode = $OPcode + "8BD9"
EndFunc   ;==>Mov_EBX_ECX

Func Mov_EBX_EDI()
    $OPcode = $OPcode + "8BDF"
EndFunc   ;==>Mov_EBX_EDI

Func Mov_EBX_EDX()
    $OPcode = $OPcode + "8BDA"
EndFunc   ;==>Mov_EBX_EDX

Func Mov_EBX_ESI()
    $OPcode = $OPcode + "8BDE"
EndFunc   ;==>Mov_EBX_ESI

Func Mov_EBX_ESP()
    $OPcode = $OPcode + "8BDC"
EndFunc   ;==>Mov_EBX_ESP

Func Mov_ECX_EBP()
    $OPcode = $OPcode + "8BCD"
EndFunc   ;==>Mov_ECX_EBP

Func Mov_ECX_EAX()
    $OPcode = $OPcode + "8BC8"
EndFunc   ;==>Mov_ECX_EAX

Func Mov_ECX_EBX()
    $OPcode = $OPcode + "8BCB"
EndFunc   ;==>Mov_ECX_EBX

Func Mov_ECX_EDI()
    $OPcode = $OPcode + "8BCF"
EndFunc   ;==>Mov_ECX_EDI

Func Mov_ECX_EDX()
    $OPcode = $OPcode + "8BCA"
EndFunc   ;==>Mov_ECX_EDX

Func Mov_ECX_ESI()
    $OPcode = $OPcode + "8BCE"
EndFunc   ;==>Mov_ECX_ESI

Func Mov_ECX_ESP()
    $OPcode = $OPcode + "8BCC"
EndFunc   ;==>Mov_ECX_ESP

Func Mov_EDX_EBP()
    $OPcode = $OPcode + "8BD5"
EndFunc   ;==>Mov_EDX_EBP

Func Mov_EDX_EBX()
    $OPcode = $OPcode + "8BD3"
EndFunc   ;==>Mov_EDX_EBX

Func Mov_EDX_ECX()
    $OPcode = $OPcode + "8BD1"
EndFunc   ;==>Mov_EDX_ECX

Func Mov_EDX_EDI()
    $OPcode = $OPcode + "8BD7"
EndFunc   ;==>Mov_EDX_EDI

Func Mov_EDX_EAX()
    $OPcode = $OPcode + "8BD0"
EndFunc   ;==>Mov_EDX_EAX

Func Mov_EDX_ESI()
    $OPcode = $OPcode + "8BD6"
EndFunc   ;==>Mov_EDX_ESI

Func Mov_EDX_ESP()
    $OPcode = $OPcode + "8BD4"
EndFunc   ;==>Mov_EDX_ESP

Func Mov_ESI_EBP()
    $OPcode = $OPcode + "8BF5"
EndFunc   ;==>Mov_ESI_EBP

Func Mov_ESI_EBX()
    $OPcode = $OPcode + "8BF3"
EndFunc   ;==>Mov_ESI_EBX

Func Mov_ESI_ECX()
    $OPcode = $OPcode + "8BF1"
EndFunc   ;==>Mov_ESI_ECX

Func Mov_ESI_EDI()
    $OPcode = $OPcode + "8BF7"
EndFunc   ;==>Mov_ESI_EDI

Func Mov_ESI_EAX()
    $OPcode = $OPcode + "8BF0"
EndFunc   ;==>Mov_ESI_EAX

Func Mov_ESI_EDX()
    $OPcode = $OPcode + "8BF2"
EndFunc   ;==>Mov_ESI_EDX

Func Mov_ESI_ESP()
    $OPcode = $OPcode + "8BF4"
EndFunc   ;==>Mov_ESI_ESP

Func Mov_ESP_EBP()
    $OPcode = $OPcode + "8BE5"
EndFunc   ;==>Mov_ESP_EBP

Func Mov_ESP_EBX()
    $OPcode = $OPcode + "8BE3"
EndFunc   ;==>Mov_ESP_EBX

Func Mov_ESP_ECX()
    $OPcode = $OPcode + "8BE1"
EndFunc   ;==>Mov_ESP_ECX

Func Mov_ESP_EDI()
    $OPcode = $OPcode + "8BE7"
EndFunc   ;==>Mov_ESP_EDI

Func Mov_ESP_EAX()
    $OPcode = $OPcode + "8BE0"
EndFunc   ;==>Mov_ESP_EAX

Func Mov_ESP_EDX()
    $OPcode = $OPcode + "8BE2"
EndFunc   ;==>Mov_ESP_EDX

Func Mov_ESP_ESI()
    $OPcode = $OPcode + "8BE6"
EndFunc   ;==>Mov_ESP_ESI

Func Mov_EDI_EBP()
    $OPcode = $OPcode + "8BFD"
EndFunc   ;==>Mov_EDI_EBP

Func Mov_EDI_EAX()
    $OPcode = $OPcode + "8BF8"
EndFunc   ;==>Mov_EDI_EAX

Func Mov_EDI_EBX()
    $OPcode = $OPcode + "8BFB"
EndFunc   ;==>Mov_EDI_EBX

Func Mov_EDI_ECX()
    $OPcode = $OPcode + "8BF9"
EndFunc   ;==>Mov_EDI_ECX

Func Mov_EDI_EDX()
    $OPcode = $OPcode + "8BFA"
EndFunc   ;==>Mov_EDI_EDX

Func Mov_EDI_ESI()
    $OPcode = $OPcode + "8BFE"
EndFunc   ;==>Mov_EDI_ESI

Func Mov_EDI_ESP()
    $OPcode = $OPcode + "8BFC"
EndFunc   ;==>Mov_EDI_ESP
Func Mov_EBP_EDI()
    $OPcode = $OPcode + "8BDF"
EndFunc   ;==>Mov_EBP_EDI

Func Mov_EBP_EAX()
    $OPcode = $OPcode + "8BE8"
EndFunc   ;==>Mov_EBP_EAX

Func Mov_EBP_EBX()
    $OPcode = $OPcode + "8BEB"
EndFunc   ;==>Mov_EBP_EBX

Func Mov_EBP_ECX()
    $OPcode = $OPcode + "8BE9"
EndFunc   ;==>Mov_EBP_ECX

Func Mov_EBP_EDX()
    $OPcode = $OPcode + "8BEA"
EndFunc   ;==>Mov_EBP_EDX

Func Mov_EBP_ESI()
    $OPcode = $OPcode + "8BEE"
EndFunc   ;==>Mov_EBP_ESI

Func Mov_EBP_ESP()
    $OPcode = $OPcode + "8BEC"
EndFunc   ;==>Mov_EBP_ESP
;Push
;+++++++++++++++++++++++++++++++++++
Func Push($i)
    ;If $i <= 255 Then
    ;$OPcode = $OPcode + "6A" + Int2Hex($i, 2)
    ;Else
    $OPcode = $OPcode + "68" + Int2Hex($i, 8)
    ;EndIf
EndFunc   ;==>Push

Func Push_DWORD_Ptr($i)
    $OPcode = $OPcode + "FF35" + Int2Hex($i, 8)
EndFunc   ;==>Push_DWORD_Ptr

Func Push_EAX()
    $OPcode = $OPcode + "50"
EndFunc   ;==>Push_EAX

Func Push_ECX()
    $OPcode = $OPcode + "51"
EndFunc   ;==>Push_ECX

Func Push_EDX()
    $OPcode = $OPcode + "52"
EndFunc   ;==>Push_EDX

Func Push_EBX()
    $OPcode = $OPcode + "53"
EndFunc   ;==>Push_EBX
Func Push_ESP()
    $OPcode = $OPcode + "54"
EndFunc   ;==>Push_ESP

Func Push_EBP()
    $OPcode = $OPcode + "55"
EndFunc   ;==>Push_EBP

Func Push_ESI()
    $OPcode = $OPcode + "56"
EndFunc   ;==>Push_ESI

Func Push_EDI()
    $OPcode = $OPcode + "57"
EndFunc   ;==>Push_EDI
;LEA
Func Lea_EAX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D40" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D80" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_EAX_Add

Func Lea_EAX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D43" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D83" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_EBX_Add

Func Lea_EAX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D41" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D81" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_ECX_Add

Func Lea_EAX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D42" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D82" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_EDX_Add

Func Lea_EAX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D46" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D86" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_ESI_Add

Func Lea_EAX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D40" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D80" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_ESP_Add

Func Lea_EAX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4424" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8424" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_EBP_Add

Func Lea_EAX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D47" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D87" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EAX_DWORD_Ptr_EDI_Add

Func Lea_EBX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D58" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D98" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_EAX_Add

Func Lea_EBX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5C24" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9C24" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_ESP_Add

Func Lea_EBX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5B" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9B" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_EBX_Add

Func Lea_EBX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D59" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D99" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_ECX_Add

Func Lea_EBX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5A" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9A" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_EDX_Add

Func Lea_EBX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5F" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9F" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_EDI_Add

Func Lea_EBX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5D" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9D" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_EBP_Add

Func Lea_EBX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5E" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9E" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EBX_DWORD_Ptr_ESI_Add

Func Lea_ECX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D48" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D88" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_EAX_Add

Func Lea_ECX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4C24" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8C24" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_ESP_Add

Func Lea_ECX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4B" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8B" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_EBX_Add

Func Lea_ECX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D49" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D89" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_ECX_Add

Func Lea_ECX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4A" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8A" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_EDX_Add

Func Lea_ECX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4F" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8F" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_EDI_Add

Func Lea_ECX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4D" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8D" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_EBP_Add

Func Lea_ECX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D4E" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D8E" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_ECX_DWORD_Ptr_ESI_Add

Func Lea_EDX_DWORD_Ptr_EAX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D50" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D90" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_EAX_Add

Func Lea_EDX_DWORD_Ptr_ESP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D5424" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D9424" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_ESP_Add

Func Lea_EDX_DWORD_Ptr_EBX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D53" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D93" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_EBX_Add

Func Lea_EDX_DWORD_Ptr_ECX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D51" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D91" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_ECX_Add

Func Lea_EDX_DWORD_Ptr_EDX_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D52" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D92" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_EDX_Add

Func Lea_EDX_DWORD_Ptr_EDI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D57" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D97" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_EDI_Add

Func Lea_EDX_DWORD_Ptr_EBP_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D55" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D95" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_EBP_Add

Func Lea_EDX_DWORD_Ptr_ESI_Add($i)
    If $i <= 255 Then
        $OPcode = $OPcode + "8D56" + Int2Hex($i, 2)
    Else
        $OPcode = $OPcode + "8D96" + Int2Hex($i, 8)
    EndIf
EndFunc   ;==>Lea_EDX_DWORD_Ptr_ESI_Add

;POP
Func Pop_EAX()
    $OPcode = $OPcode + "58"
EndFunc   ;==>Pop_EAX

Func Pop_EBX()
    $OPcode = $OPcode + "5B"
EndFunc   ;==>Pop_EBX

Func Pop_ECX()
    $OPcode = $OPcode + "59"
EndFunc   ;==>Pop_ECX

Func Pop_EDX()
    $OPcode = $OPcode + "5A"
EndFunc   ;==>Pop_EDX

Func Pop_ESI()
    $OPcode = $OPcode + "5E"
EndFunc   ;==>Pop_ESI

Func Pop_ESP()
    $OPcode = $OPcode + "5C"
EndFunc   ;==>Pop_ESP

Func Pop_EDI()
    $OPcode = $OPcode + "5F"
EndFunc   ;==>Pop_EDI

Func Pop_EBP()
    $OPcode = $OPcode + "5D"
EndFunc   ;==>Pop_EBP

Func Ptr(ByRef $Add)
    $Ptr = VarPtr($Add)
EndFunc   ;==>Ptr

Func Float4Int($Ans)  ;?????
    Dim $AB, $a
    CopyMemory($AB, $Ans, 4)
    $Float4Int = $AB
EndFunc   ;==>Float4Int

;Func  Float8Int(ByRef Ans) ;?????
;    Dim AB As Long
;    CopyMemory AB, Ans, 8
;    Float8Int = AB
;EndFunc
__wadim is offline  
Old 01/03/2009, 16:16   #3
 
elite*gold: 0
Join Date: Jan 2007
Posts: 1,753
Received Thanks: 450
Azunai is offline  
Old 01/03/2009, 16:24   #4
 
elite*gold: 0
Join Date: Aug 2006
Posts: 515
Received Thanks: 96
Hm cool
Jacob_G is offline  
Old 01/03/2009, 22:08   #5
 
elite*gold: 0
Join Date: Jul 2008
Posts: 271
Received Thanks: 12
was hat man jetzt dadurch genau für vorteile kenne mich nicht genau mit dem assembler system aus^^
darthwitch is offline  
Old 01/03/2009, 22:18   #6
 
elite*gold: 0
Join Date: Apr 2008
Posts: 1,874
Received Thanks: 212
Soweit ich weiss ist assambler vieeell schneller
NBA is offline  
Old 01/03/2009, 22:54   #7
 
elite*gold: 0
Join Date: Aug 2006
Posts: 515
Received Thanks: 96
Naja wenn man das über Au3 benutzt nicht, jedoch hat man dann die Macht!
Jacob_G is offline  
Old 01/04/2009, 17:29   #8
 
elite*gold: 0
Join Date: Jul 2008
Posts: 271
Received Thanks: 12
Welche macht :-D woltle eig nur wissen was man dann so für vorteile hat :-D nicht was starwars mäsiges oder so *gg*
darthwitch is offline  
Old 01/04/2009, 18:11   #9
 
elite*gold: 0
Join Date: Aug 2006
Posts: 515
Received Thanks: 96
Das ist auch nid Star Wars mäsig^^, mit Assembler kannst du alles am PC machen. Ein Assemblerbefehl entspricht einem Maschinenbefehl, deswegen ist es auch so schnell. Du kannst Sachen programieren ohne den Schlack mit rein zu packen .

Hier ein Beispiel in MASM für Hello World
Code:
DATA SEGMENT              ;- Beginn des Datensegments
Meldung db "Hello World"   ;- Die Zeichenkette "Hello World"
        db "$"             ;- Endzeichen der Zeichenkette
DATA ENDS                 ;- Ende des Datensegment
CODE SEGMENT              ;- Beginn des Codesegements
ASSUME CS:CODE,DS:DATA     ;- Dem Assembler die Segmente mitteilen
Anfang:                    ;- Label für den Anfang des Programms
mov ax, DATA               ;- das Daten...
mov ds, ax                 ;  ...segment laden
mov dx, offset Meldung     ;- den Text in das Datenregister laden
mov ah, 09h                ;- dem Betriebssystem mitteilen, was wir wollen
int 21h                    ;- diesen Befehl ausführen (hier Ausgabe des Texts)
mov ax, 4C00h              ;- dem Betriebssystem wieder mitteilen, was wir wollen
int 21h                    ;- diesen Befehl wieder ausführen (Programm beenden)
CODE ENDS                 ;- Ende des Codesegments
END Anfang                 ;- dem Assembler das Ende des Labels Anfang mitteilen
Jacob_G is offline  
Old 01/05/2009, 02:20   #10
 
elite*gold: 0
Join Date: Jun 2006
Posts: 239
Received Thanks: 31
Beim Botcoding mit AutoIt doch wohl eher für die Katz oder?
Illuminatus is offline  
Old 01/05/2009, 10:31   #11
 
elite*gold: 0
The Black Market: 123/0/1
Join Date: Apr 2006
Posts: 1,722
Received Thanks: 474
Quote:
Originally Posted by Illuminatus View Post
Beim Botcoding mit AutoIt doch wohl eher für die Katz oder?
Wenn du das so siehst
blauwiggle is offline  
Old 01/05/2009, 13:36   #12
 
elite*gold: 0
Join Date: Jun 2006
Posts: 239
Received Thanks: 31
Quote:
Originally Posted by blauwiggle View Post
Wenn du das so siehst
Ist dem nicht so? Wenn der einzige Grund Geschwindigkeit ist (was bei einem Bot wohl eher irrelevant ist), kann man sich das umständliche asm doch schenken...
Und für alles, was tiefer geht als ControlSend(), (hooking, detouring usw.) würde ich auf c/c++ umsteigen...
Seh ich das falsch? Erweitere meinen horizont!
Illuminatus is offline  
Old 01/06/2009, 19:34   #13
 
elite*gold: 0
Join Date: Jan 2007
Posts: 1,753
Received Thanks: 450
Quote:
Und für alles, was tiefer geht als ControlSend(), (hooking, detouring usw.) würde ich auf c/c++ umsteigen...
wozu neue syntax lernen wenn der asm code immer asm code bleibt
Azunai is offline  
Old 01/06/2009, 22:17   #14
 
elite*gold: 0
Join Date: Jun 2006
Posts: 239
Received Thanks: 31
Neuer Syntax? Also bitte... Soviel kommt da auch net dazu...
Nuja, ich seh den Sinn dahinter immernoch net :-)
Illuminatus is offline  
Old 01/07/2009, 20:55   #15
 
elite*gold: 0
Join Date: Jan 2007
Posts: 1,753
Received Thanks: 450
stell dir vor du hast nen umfangreichen bot in au3 geschrieben, brauchst aber ne funktion die nur über asm geht

warum dann nicht einfach die func in asm schreiben ?
statt umständlich in c ne exe oder dll ? die dann geladen werden muss ?
Azunai is offline  
Reply


Similar Threads Similar Threads
Assembler Befehle :D HELP ME!!!
05/18/2010 - General Coding - 12 Replies
Also wenn ich das jetzt richtig verstanden habe Startet der Patcher eines Spiels am Ende Das Anticheat system (wenn es eins beim spiel gibt) und für diesen Start(vom Anticheat System) Gibt es ja Assembler Befehle die An Bestimmten Stellen in Hexadressen stehen so jetzt meine Fragen :D 1. Sind diese Befehle immer anders Anderer Prozess soll gestartet werden andere Adresse? 2. Wie heißt der Nop Assembler Befehl 3. Also ich stelle mir das so vor^^:Adressen zum starten von HackShield oder...
Assembler
04/19/2010 - General Coding - 9 Replies
Hallo und guten Morgen|Tag|Abend, ich schreibe gerade an einen TeleportHack in CS:S. So nun hab ich die Addressen die mithilfe von WriteProcessMemory geändert werden. Das Problem ist, das das spiel so schnell die werte ändert, dass ich mich nur ca. 10ingame Meter bewege und dan sofort wieder zurück.
Assembler erlernen
03/17/2010 - General Coding - 23 Replies
Hey Leute, ich bin neu hier=) Ich würde gerne Assembler lernen. Habe schon Erfahrung in C++. Ich kann mich jedoch schon seit einer Woche nicht entscheiden welchen Assembler ich nehmen soll, auch weil ich bisher für keinen ein richtiges Anfängertutorial gefunden habe=( Was würdet ihr mir empfehlen? NASM, FASM? oder sonst was? MASM wollt ich eg nicht, ist wieder so Microsoft spezifisch...:D Ihr im Forum ist ja ein Tutorial verlinkt für TASM, wär das zu empfehlen? Jedoch ist doch TASM...
Assembler
02/26/2010 - General Coding - 4 Replies
hey leute, ich wollte gern Anfangen in Assembler (MASM) zu proggen (hab schon einbisschen Kenntnisse in C++ und Python) hab auch schon den MASM64 Assembler gedownloadet (hab einen 64bit). ich hab auch ein kleines hello_wolrd! programm geschrieben, hab es dann mit Notepad++ als hello_world.asm abgespeichert, aber jetzt weiß ich nicht mehr weiter^^, (wie "linke" ich die Datei???) würde mich freuen, wenn mir jemand helfen könnte^^ *kennt jemand noch ein gutes MASM-Tutorial? (in Deutsch...
Assembler
08/04/2009 - General Coding - 9 Replies
Hallo, kennt jemand ein gutes oder gute Tutorials über Assembler?? Bin kein Pro in Sachen Programmieren, also sollte es nicht so schwer sein. (ich weiss, dass es nicht leicht ist ASM zu lernen) Vielleicht kann mir jemand die Programme sagen, die ich brauche um ein ASM Programm zuschreiben?? Danke im Voraus!!!!!! :handsdown::handsdown::confused:



All times are GMT +1. The time now is 03:00.


Powered by vBulletin®
Copyright ©2000 - 2021, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.
This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

BTC: 33E6kMtxYa7dApCFzrS3Jb7U3NrVvo8nsK
ETH: 0xc6ec801B7563A4376751F33b0573308aDa611E05

Support | Contact Us | FAQ | Advertising | Privacy Policy | Terms of Service | Abuse
Copyright ©2021 elitepvpers All Rights Reserved.