// Primary opcode map. This is the root of the opcode lookup tree
SOpcodeDef OpcodeMap0[256] = {
//  name         instset prefix   format  dest.   source1 source2 source3 EVEX    MVEX    link    options
   {"add",       0     , 0xC50  , 0x13  , 0x1   , 0x1001, 0     , 0     , 0     , 0     , 0     , 0     },    // 00
   {"add",       0     , 0x1D50 , 0x13  , 0x9   , 0x1009, 0     , 0     , 0     , 0     , 0     , 0     },    // 01
   {"add",       0     , 0      , 0x12  , 0x1001, 0x1   , 0     , 0     , 0     , 0     , 0     , 0     },    // 02
   {"add",       0     , 0x1100 , 0x12  , 0x1009, 0x9   , 0     , 0     , 0     , 0     , 0     , 0     },    // 03
   {"add",       0     , 0      , 0x41  , 0xA1  , 0x21  , 0     , 0     , 0     , 0     , 0     , 0     },    // 04
   {"add",       0     , 0x1100 , 0x81  , 0xA9  , 0x28  , 0     , 0     , 0     , 0     , 0     , 0x80  },    // 05
   {"push es",   0x8000, 0x2    , 0x1   , 0     , 0     , 0     , 0     , 0     , 0     , 0     , 0     },    // 06
   {"pop  es",   0x8000, 0x2    , 0x1   , 0     , 0     , 0     , 0     , 0     , 0     , 0     , 0     },    // 07
   {"or",        0     , 0xC50  , 0x13  , 0x1   , 0x1001, 0     , 0     , 0     , 0     , 0     , 0     },    // 08
   {"or",        0     , 0x1D50 , 0x13  , 0x9   , 0x1009, 0     , 0     , 0     , 0     , 0     , 0     },    // 09
   {"or",        0     , 0      , 0x12  , 0x1001, 0x1   , 0     , 0     , 0     , 0     , 0     , 0     },    // 0A
   {"or",        0     , 0x1100 , 0x12  , 0x1009, 0x9   , 0     , 0     , 0     , 0     , 0     , 0     },    // 0B
   {"or",        0     , 0      , 0x41  , 0xA1  , 0x31  , 0     , 0     , 0     , 0     , 0     , 0     },    // 0C
   {"or",        0     , 0x1100 , 0x81  , 0xA9  , 0x39  , 0     , 0     , 0     , 0     , 0     , 0x80  },    // 0D

// Opcode map for EVEX 0F 3A 39. Indexed by W bit
SOpcodeDef OpcodeMap121[] = {
   {"vextracti32x4",0x20,0x868200,0x53  , 0x406 , 0x1203, 0x31  , 0     , 0x20  , 0     , 0     , 0     },    // 0F 3A 39
   {"vextracti64x2",0x20,0x869200,0x53  , 0x406 , 0x1203, 0x31  , 0     , 0x20  , 0     , 0     , 0     }};   // 0F 3A 39

// Opcode map for 0F 3A 18. Indexed by EVEX
SOpcodeDef OpcodeMap122[] = {
   {"vinsertf128",0x19 ,0x9F8200, 0x59  , 0x1250, 0x1250, 0x450 , 0x31  , 0x30  , 0     , 0     , 0     },    // 0F 3A 18
   {0,           0x123 , 0      , 0x59  , 0     , 0     , 0     , 0     , 0     , 0     , 0xC   , 0     }};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WriteAsmPatch пишет патч по адресу address
// возвращаeт указатель на патч
// аргументы ... - это строки, содержащие код на ассемблере
// распознаются все инструкции, распознаваемые OllyDbg 1.04 (вплоть до MMX и amd 3DNow! включительно)
// ВНИМАНИЕ! в отличие от OllyDbg, целые числа не имеющие префикса 0x или постфикса h читаются как ДЕСЯТЕРИЧНЫЕ!
// поэтому не забывайте писать шеснадцатеричные числа явно
// В одной строке может быть несколько инструкций, разделенных символом ';'
// Код на ассемблере может содержать метки;
// объявление метки - label_name: (имя метки, двоеточие),
// использование label_name (имя без двоеточия);
// максимальная длина имени метки - 39 символов, имя может содержать буквы, цифры, символы '_' и '.';
// код может содержать псевдоинструкцию times (пишет заданное количество раз следующую инструкцию)
// например, результатом "times 3 nop" будет код 90 90 90
// код может содержать псевдоинструкцию _ExecCopy <адрес>, <размер> (пишет код из памяти по адресу <адрес> размером <размер>)
// код может содержать псевдоинструкции db <число>, dw <число>, dd <число или метка>.
// Строка может содержать формат-символы %d. В этом случае за строкой должно следовать соответствующее количество четырехбайтовых чисел (знаковые/беззнаковые/адреса/...)
// ВНИМАНИЕ! последним аргументом (строкой) должен обязательно быть 0 (NULL)!
// абстрактный пример: WriteAsmPatch(0x112233, "begin: call %d", MyFunc, "jmp begin", "jne dword [%d]", 0xAABBCC, 0);
inline Patch* WriteAsmPatch(_ptr_ address, ...)


////////////////////////////////////////////////////////////
// WriteAsmHook пишет по адресу address примитивный хук
// а именно LoHook без вызова высокоуровневой функции.
// тело хука пишется прямо в вызове CreateHexHook или WriteHexHook
// таким же образом как пишется патч с помощью WriteAsmPatch (см. WriteAsmPatch)
// В отличие метода WriteAsmPatch здесь код может содержать (а может не содержать) псевдокоманду _ExecDefault,
// котроая выполняет затертый хуком код
// ВНИМАНИЕ! в коде не может быть больше одной псевдокоманды _ExecDefault
// возвращает указатель на LoHook хук
// ВНИМАНИЕ! последним аргументом (строкой) должен обязательно быть 0 (NULL)!
// абстрактный пример: WriteAsmHook(0x112233, "cmp eax, 0; jne SkipDefault; _ExecDefault; jmp End; SkipDefault: mov ecx, 2; End: retn", 0);
inline LoHook* WriteAsmHook(_ptr_ address, ...)

#define _DO_JOIN2( a1, a2 ) a1##a2
#define JOIN2( a1, a2 ) _DO_JOIN2( a1, a2 )
#define _DO_JOIN3( a1, a2, a3 ) a1##a2##a3
#define JOIN3( a1, a2, a3 ) _DO_JOIN3( a1, a2, a3 )

#define HOOK_CALLTYPE__stdcall    0
#define HOOK_CALLTYPE__thiscall 1
#define HOOK_CALLTYPE__fastcall 2
#define HOOK_CALLTYPE__cdecl    3

#define HOOKFUNC_CALLTYPE_00     __stdcall
#define HOOKFUNC_CALLTYPE_01     __fastcall
#define HOOKFUNC_CALLTYPE_02     __fastcall
#define HOOKFUNC_CALLTYPE_03     __cdecl

#define HOOKFUNC_CALLTYPE_10     __stdcall
#define HOOKFUNC_CALLTYPE_11     __stdcall
#define HOOKFUNC_CALLTYPE_12     __stdcall
#define HOOKFUNC_CALLTYPE_13     __stdcall

#define HOOKFUNC_CALLTYPE_20    __stdcall
#define HOOKFUNC_CALLTYPE_21    __stdcall
#define HOOKFUNC_CALLTYPE_22    __stdcall
#define HOOKFUNC_CALLTYPE_23    __stdcall

#define __ARGS(...) __VA_ARGS__
#define EXTENDED_ARGS(...) HiHook* hook, __VA_ARGS__

#define HOOK_ARGS_00                __ARGS
#define HOOK_ARGS_01(this_, ...)    this_, _dword_ ___no_used, __VA_ARGS__
#define HOOK_ARGS_02                __ARGS
#define HOOK_ARGS_03                __ARGS

#define HOOK_ARGS_10     EXTENDED_ARGS
#define HOOK_ARGS_11     EXTENDED_ARGS
#define HOOK_ARGS_12     EXTENDED_ARGS
#define HOOK_ARGS_13     EXTENDED_ARGS

#define HOOK_ARGS_20     EXTENDED_ARGS
#define HOOK_ARGS_21     EXTENDED_ARGS
#define HOOK_ARGS_22     EXTENDED_ARGS
#define HOOK_ARGS_23     EXTENDED_ARGS

#define INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
#define INTERNAL_EXPAND(x) x

#define INTERNAL_GET_ARG_COUNT_PRIVATE(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, count, ...) count
#define EXPAND_ARGS_PRIVATE_1(...) INTERNAL_EXPAND(INTERNAL_GET_ARG_COUNT_PRIVATE(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3))
#define EXPAND_ARGS_PRIVATE_2(...) INTERNAL_EXPAND(INTERNAL_GET_ARG_COUNT_PRIVATE(__VA_ARGS__, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3))
#define RIGHT_CALLTYPE_0(...)    0
#define RIGHT_CALLTYPE_1(...)    EXPAND_ARGS_PRIVATE_1(INTERNAL_ARGS_AUGMENTER(__VA_ARGS__))
#define RIGHT_CALLTYPE_2(...)    EXPAND_ARGS_PRIVATE_2(INTERNAL_ARGS_AUGMENTER(__VA_ARGS__))
#define    RIGHT_CALLTYPE_3(...)    3


#define Create_HiHook(address, t, st, rt, ct, name, args, body) \
[]() -> HiHook*\
{\
static HiHook* inline_hook;\
typedef rt(ct *_DefaultFunc_)args; \
typedef rt(JOIN3(HOOKFUNC_CALLTYPE_, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args) *_HookFunc_)(JOIN3(HOOK_ARGS_, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args) args); \
_HookFunc_ func_name = [](JOIN3(HOOK_ARGS_, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args) args) -> rt body;\
inline_hook = _PI->CreateHiHook(address, t, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args, func_name); \
return inline_hook;\
}()


#define Write_HiHook(address, t, st, rt, ct, name, args, body) \
[]() -> HiHook*\
{\
static HiHook* inline_hook;\
typedef rt(ct *_DefaultFunc_)args; \
typedef rt(JOIN3(HOOKFUNC_CALLTYPE_, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args) *_HookFunc_)(JOIN3(HOOK_ARGS_, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args) args); \
_HookFunc_ func_name = [](JOIN3(HOOK_ARGS_, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args) args) -> rt body;\
inline_hook = _PI->WriteHiHook(address, t, st, JOIN2(RIGHT_CALLTYPE_, HOOK_CALLTYPE##ct) args, func_name); \
return inline_hook;\
}()

#define DefaultFunc ((_DefaultFunc_)inline_hook->GetDefaultFunc())
#define OriginalFunc ((_DefaultFunc_)inline_hook->GetOriginalFunc())

int __stdcall LoHook_TracePoint(LoHook* h, HookContext* c)
{
    static int counter = 0;
    D_OUT(g, "TracePoint at %X %d", h->GetAddress(), counter++); // это вывод в отладочную консоль
    return EXEC_DEFAULT;
}


inline void TP(_ptr_ address)
{
    _PI->WriteLoHook(address, LoHook_TracePoint);
}

//далее в месте инициализации хуков пишем:
TP(0xABCDEF);
TP(0xAABBCC);
TP(0xBADF00D);

// и каждый раз при выполнении кода по этим адресам мы будем знать что он выполняется
// т.е. мы будем знать при каких и после каких наших действий в программе интересующий нас код выполняется.

    "mov dword [%d], esp", &esp_register,
        "pushfd",
        "pop dword [%d]", &flags_register,
        "sub esp, %d", stack_delta,
        "push dword [%d]", &flags_register,
        "push %d", address + size,

        "push edi; push esi; push ebp",
        "push dword [%d]", &esp_register,
        "push ebx; push edx; push ecx; push eax",

        "push esp", //context
        "push %d", this,
        "call %d", func,

        "cmp eax, 0", // SKIP_DEFAULT
        "jne exec_default",

        // SKIP_DEFAULT
        "pop eax; pop ecx; pop edx; pop ebx",
        "pop dword [%d]", &esp_register,
        "pop ebp; pop esi; pop edi",

        "pop dword [%d]", &return_address,
        "popfd",
        "mov esp, [%d]", &esp_register,

        "jmp dword ptr [%d]", &return_address,

        //EXEC_DEFAULT
"exec_default:",
        "pop eax; pop ecx; pop edx; pop ebx",
        "pop dword [%d]", &esp_register,
        "pop ebp; pop esi; pop edi",

        "pop [%d]", &return_address,
        "popfd",
        "mov esp, [%d]", &esp_register,

"tail_code: times %d nop", MAX_COPIED_HOOKPATCH_DEFAULT_CODE,

        "jmp dword ptr [%d]", &return_address,

    t0 = GetTickCount();

    for (int i = 0; i < 500000000; i++)
    {
        __asm
        {
            pushad
            popad
        }
    }

    printf("pushad...  : %d\n", GetTickCount() - t0);


    t0 = GetTickCount();

    for (int i = 0; i < 500000000; i++)
    {
        __asm
        {
            push edi
            push esi
            push ebp
            push esp
            push ebx
            push edx
            push ecx
            push eax
            pop eax
            pop ecx
            pop edx
            pop ebx
            pop esp
            pop ebp
            pop esi
            pop edi
        }
    }

    printf("push edi...: %d\n", GetTickCount() - t0);


    t0 = GetTickCount();

    for (int i = 0; i < 500000000; i++)
    {
        __asm
        {
            push eax
            push ecx
            push edx
            push ebx
            push esp
            push ebp
            push esi
            push edi
            pop edi
            pop esi
            pop ebp
            pop esp
            pop ebx
            pop edx
            pop ecx
            pop eax
        }
    }

    printf("push eax...: %d\n", GetTickCount() - t0);

        "push esp", //esp0
        "pushfd",
        "sub esp, %d", stack_delta,
        "push dword [esp + %d]", stack_delta, //fd
        "push %d", address + size,

        "push edi; push esi; push ebp",
        "push dword [esp + %d]", stack_delta + 0x18, //esp0
        "push ebx; push edx; push ecx; push eax",

        "push esp", //context
        "push %d", this,
        "call %d", func,

        "cmp eax, 0", // SKIP_DEFAULT

        "pop eax; pop ecx; pop edx; pop ebx",
        "pop ebp",
        "pop ebp; pop esi; pop edi",

        "pop dword [%d]", &return_address,

        "jne exec_default",

        // SKIP_DEFAULT
        "popfd",
        "mov esp, [esp - 0x18]",

        "jmp dword ptr [%d]", &return_address,

        //EXEC_DEFAULT
"exec_default:",
        "popfd",
        "mov esp, [esp - 0x18]",

"tail_code: times %d nop", MAX_COPIED_HOOKPATCH_DEFAULT_CODE,

        "jmp dword ptr [%d]", &return_address,

Failed to read data at 33345B20.
EIP: Era.4CE3. Code: C0000005

> Registers
EAX: 0028FD58
ECX: 00000000
EDC: 33345B20
EBX: H3era.0068864C (aGenrltxt_txt)
ESP: 0028FD40
EBP: 0028FD64
ESI: H3era.02808DB4 (dword_6ACEBC + 34979576)
EDI: H3era.0079ECC0 (dword_6ACEBC + 990724)

> Callstack
02C60730
H3era.0055BF05
H3era.0055C02F
H3era.005B946A (A0_Load_genrl_txt_sub_5B9460 + 10)
H3era.004F8133
H3era.0061A964
Kernel32.1336A
Ntdll.398F2
Ntdll.398C5

> Stack
0028FD2C: FFFFFF00
0028FD30: 0028FDA8
0028FD34: 00000005
0028FD38: 00000003
0028FD3C: 00000000
0028FD40*: 33345B20
0028FD44: Era.37193
0028FD48: 0028FD5C
0028FD4C: 0028FE68
0028FD50: Era.371D5
0028FD54: 0028FD64
0028FD58: 00000000
0028FD5C: 00000000
0028FD60: 00000000
0028FD64: 0028FE20
0028FD68: 02C60730
0028FD6C: 029A2A48
0028FD70: 0028FD74
0028FD74: 00000046
0028FD78: H3era.02808DB4 (dword_6ACEBC + 34979576)
0028FD7C: H3era.0067F554 (dword_67F554)
0028FD80: H3era.0068864C (aGenrltxt_txt)
0028FD84: 0028FE1C
0028FD88: 0028FE20
0028FD8C: H3era.02808DB4 (dword_6ACEBC + 34979576)
0028FD90: H3era.0079ECC0 (dword_6ACEBC + 990724)
0028FD94: H3era.004FB10C
0028FD98: 00000206
0028FD9C: H3era.00677D6E (aRb + 2)
0028FDA0: 00000001
0028FDA4: 00000000
0028FDA8: 0000000C
0028FDAC: 00000000
0028FDB0: 00000001
0028FDB4: 00000003
0028FDB8: 80000000
0028FDBC: 00000003
0028FDC0: 00000000
0028FDC4: 0028FDF0
0028FDC8: H3era.00621116 (__openfile + 324)

PROGRAM AngelRun;
USES Win, Utils, APIHook;

CONST
    APP_TITLE = 'Angel Run v1.0';    // Заголовок для сообщений приложения

PROCEDURE Err (Mes: STRING);
BEGIN
    Win.MessageBox(0, PCHAR(Mes), APP_TITLE, Win.MB_ICONSTOP);
    HALT;
END; // .procedure Err

VAR
    ExePath: STRING;                        // Путь к исполняемому файлу
    DllPath: STRING;                        // Путь к внедряемой DLL
    PInfo: TProcessInformation;    // Информация о процессе

BEGIN
    IF ParamCount = 0 THEN BEGIN
        Err('Не указан путь к исполняемому файлу');
    END; // .if
    IF ParamCount = 1 THEN BEGIN
        Err('Не указан путь к внедряемой DLL');
    END; // .if
    ExePath:=ParamStr(1);
    IF NOT Utils.FileExists(ExePath) THEN BEGIN
        Err('Указанный файл "'+ExePath+'" не существует');
    END; // .if
    DllPath:=ParamStr(2);
    IF NOT Utils.FileExists(DllPath) THEN BEGIN
        Err('Указанный файл "'+DllPath+'" не существует');
    END; // .if
    APIHook.RunProcessWithHookDll(ExePath, DllPath, PInfo);
END.

PROCEDURE RunProcessWithHookDll(ExeFile, DllFile: STRING; VAR PInfo: TProcessInformation);
VAR
    si: TStartupInfo;
    AsmBlockAddr: POINTER;
    Temp: INTEGER;
    WriteBuf: ARRAY[0..C_ASMBLOCKSIZE-1] OF BYTE;
    Buf: INTEGER;
    LibNameAddr: POINTER;
    Kernel: INTEGER;
    
BEGIN
    FillChar(si, SizeOf(si), #0);
    si.cb:=SizeOf(si);
    ExeFile:=GetFullPath(ExeFile);
    DllFile:=GetFullPath(DllFile);
    CreateProcess(PCHAR(ExeFile), PCHAR(CmdLine), NIL, NIL, FALSE, CREATE_SUSPENDED, NIL, PCHAR(ExtractFilePath(ExeFile)), si, PInfo);
    AsmBlockAddr:=VirtualAllocEx(PInfo.hProcess, NIL, C_ASMBLOCKSIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    LibNameAddr:=VirtualAllocEx(PInfo.hProcess, NIL, Length(DllFile)+1, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    Kernel:=LoadLibrary('kernel32.dll');
    Buf:=INTEGER(@WriteBuf);
    PBYTE(Buf)^:=$68;
    PINTEGER(Buf+1)^:=INTEGER(LibNameAddr);
    PBYTE(Buf+5)^:=$E8;
    PINTEGER(Buf+6)^:=INTEGER(GetProcAddress(Kernel, 'LoadLibraryA'))-INTEGER(AsmBlockAddr)-10;
    PBYTE(Buf+10)^:=$68;
    PINTEGER(Buf+11)^:=0;
    PBYTE(Buf+15)^:=$E8;
    PINTEGER(Buf+16)^:=INTEGER(GetProcAddress(Kernel, 'ExitThread'))-INTEGER(AsmBlockAddr)-20;
    WriteProcessMemory(PInfo.hProcess, LibNameAddr, PCHAR(DllFile), Length(DllFile)+1, CARDINAL(Temp));
    WriteProcessMemory(PInfo.hProcess, AsmBlockAddr, @WriteBuf, C_ASMBLOCKSIZE, CARDINAL(Temp));
    WaitForSingleObject
  (
    CreateRemoteThread(PInfo.hProcess, NIL, 0, AsmBlockAddr, @Temp, 0, CARDINAL(Temp)),
    Windows.INFINITE
    );
    ResumeThread(PInfo.hThread);
END; // .procedure RunProcessWithHookDll