[INC] Memory Extended 2.7

enum ASMRegister
{
    ASMRegister_EAX,
    ASMRegister_ECX,
    ASMRegister_EDX,
    ASMRegister_EBX,
    ASMRegister_ESP,
    ASMRegister_EBP,
    ASMRegister_ESI,
    ASMRegister_EDI
}

enum struct ASMInstructions
{
    BaseMemory mem;

    void Set(Pointer adr)
    {
        this.mem.pAddrBase = adr;
    }
    Pointer Get()
    {
        return this.mem.pAddrBase;
    }

    void PushRegister(ASMRegister reg)
    {
        this.mem.WriteByte(0x50 + view_as<int>(reg),     _,     MemoryEx_AddAfterWrite);
    }
    void Push(any value)
    {
        this.mem.WriteByte(0x68,     _,     MemoryEx_AddAfterWrite);
        this.mem.WriteInt(value,    _,     MemoryEx_AddAfterWrite);
    }
    void PopRegister(ASMRegister reg)
    {
        this.mem.WriteByte(0x58 + view_as<int>(reg),     _,     MemoryEx_AddAfterWrite);
    }

    void Call (any value)
    {
        this.mem.WriteWord(0x15FF,     _, MemoryEx_AddAfterWrite);
        this.mem.WriteInt(value,    _,     MemoryEx_AddAfterWrite);
    }

    void Nop()
    {
        this.mem.WriteByte(0x90,     _,     MemoryEx_AddAfterWrite);
    }
    void Xchg(ASMRegister reg)
    {
        this.mem.WriteByte(0x90 + view_as<int>(reg),     _,     MemoryEx_AddAfterWrite);
    }
    void Retn()
    {
        this.mem.WriteByte(0xC3,    _,    MemoryEx_AddAfterWrite);
    }
}

stock ASMInstructions g_ASM;

#define ASM g_ASM

#define ASMHELP_SET(%0)            g_ASM.Set(%0)
#define ASMHELP_GET()            g_ASM.Get()
#define PUSH_REGISTER(%0)         g_ASM.PushRegister(ASMRegister_%0)
#define PUSH(%0)                 g_ASM.Push(%0)
#define POP_REGISTER(%0)         g_ASM.PopRegister(ASMRegister_%0)
#define CALL(%0)                 g_ASM.Call(%0)
#define NOP()                     g_ASM.Nop()
#define XCHG(%0)                 g_ASM.Xchg(ASMRegister_%0)
#define RETN()                     g_ASM.Retn()

push [string address]
call dword ptr [GetModuleHandleW]
retn

.text:1072C378 56                                      push    esi
.text:1072C379 68 EC D5 79 10                          push    offset aKernel32Dll_0 ; "kernel32.dll"
.text:1072C37E FF 15 F4 E0 78 10                       call    ds:GetModuleHandleW

Pointer pKernelStr = this.FindUnicodeString("server", "kernel32.dll");
Pointer module = this.FindValue("server", pKernelStr, 0xFF)  + PTR(0x06);

if(pKernelStr == nullptr || module == nullptr)
{
    this.ChangeSettings(false);
    LogStackTrace("GetModuleHandles failed -> Base = 0x%X pKernelStr 0x%X module 0x%X end = 0x%X", g_ServerDLL.base, pKernelStr, module, g_ServerDLL.base + PTR(g_ServerDLL.size) );
    return nullptr;
}

module = PTR(LoadFromAddress(module, NumberType_Int32));

        static int offsetForString = 0x10; // offset between string and function
        static int offsetForEnd = 0x100;

        int iLengthStr = strlen(name);

        //Теперь нужно перейти на адрес куда мы можем нужную строку + саму функцию.
        this.SetAddr((view_as<int>(g_ServerDLL.base) + g_ServerDLL.size) - offsetForEnd - offsetForString - (iLengthStr * 2)); // Address for string
        Pointer pString = this.GetAddr();

        // this.WriteUnicodeString(name) возвращает нам адрес, куда была записан последний байт строки и делаем маленькое смещения для написания уже самой функции.
        this.SetAddr( this.WriteUnicodeString(name) + PTR(offsetForString));


        Pointer pFunc = this.GetAddr();

        // Реализуем функцию из псевдокода, который был выше
        this.WriteByte(0x68,     _,     MemoryEx_AddAfterWrite); // push
        this.WriteInt(pString,    _,     MemoryEx_AddAfterWrite); // Адрес записаной unicode строки
        this.WriteWord(0x15FF,    _,     MemoryEx_AddAfterWrite); // call dword ptr
        this.WriteInt(module,    _,     MemoryEx_AddAfterWrite); // Адрес GetModuleHandleW
        this.WriteByte(0xC3,    _,    MemoryEx_AddAfterWrite); // retn

StartPrepSDKCall(SDKCall_Static);
PrepSDKCall_SetAddress(pFunc);
PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain);

Handle h = EndPrepSDKCall();
Pointer iRes = SDKCall(h);

#include <MemoryEx>

MemoryEx g_hMem;

public void OnPluginStart()
{
    RegServerCmd("sm_nobots", Cmd_NoBots);
}
public Action Cmd_NoBots(int iArgs)
{
    if(iArgs)
    {
        g_hMem.RestoreBytes();
    }
    else
    {
        if(g_hMem.Init())
        {
            g_hMem.SaveBytes(true);

            Pointer pEnd = g_hMem.GetBaseAddress("server") + PTR(g_hMem.GetModuleSize("server"));
            g_hMem.SetAddr(pEnd - PTR(0x200));

            g_hMem.WriteString("Memory", _, MemoryEx_AddAfterWrite);
            g_hMem.WriteUnicodeString("Extended", _, MemoryEx_AddAfterWrite);
            g_hMem.WriteByte(0x31, _, MemoryEx_AddAfterWrite);
            g_hMem.WriteWord(0x32, _, MemoryEx_AddAfterWrite);
            g_hMem.WriteInt(0x33, _, MemoryEx_AddAfterWrite);
        }
    }

}

#include <MemoryEx>

public void OnPluginStart()
{
    MemoryEx mem;

    if(!mem.Init()) return;

    Pointer base = mem.GetModuleHandle("kernel32.dll");
    Pointer base1 = mem.InitModule("kernel32.dll");
    Pointer base2 = mem.GetBaseAddress("kernel32.dll");

    Pointer srcds = mem.GetModuleHandle("0");

    int size = mem.GetModuleSize("kernel32.dll");

    Pointer end1 = base1 + PTR(size);
    Pointer end2 = mem.GetEndModule("kernel32.dll");

    PrintToServer("base [0x%X] == base1 [0x%X] == base2 [0x%X] size [0x%X] end1 [0x%X] == end2 [0x%X] srcds [0x%X]", base, base1, base2, size, end1, end2, srcds);
}