[Rostu]

The first thing I would like to say - the philosophy of this library is that all manipulations are reproduced without creating and needing additional files on the server.

From version 2.0 - added linux support

Due to the fact that now you can work with all dynamic libraries - all the restrictions are only in your head

Special thanks to Kailo for assistance in training ASM, working with debugger/IDA

This "weapon" was created for convenient work with other .dll, because in SourcePawn functions you can work only with 3 => server/engine/matchmaking_ds
What came of this? - Let's look at its structure =>

Since version 2.0, the structure is divided by files

1)MemoryEx/ASM_Instruction.inc - A helper file that allows you to use the most common ASM features in SourcePawn [include => MemoryEx/BaseMemory.inc]

PHP Code:

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() 


2) MemoryEx/BaseMemory.inc - Implements basic functions for more convenient work with memory

PHP Code:

void BaseMemory::SetAddr(any address)
Pointer BaseMemory::GetAddr()
void BaseMemory::Add(any iOffset)

int BaseMemory::ReadByte(int iOffset = 0)
void BaseMemory::WriteByte(any iByte, int iOffset = 0,  int flags = MemoryEx_NoNeedAdd)

int BaseMemory::ReadWord(int iOffset = 0)
void BaseMemory::WriteWord(any iByte, int iOffset = 0,  int flags = MemoryEx_NoNeedAdd)

int BaseMemory::ReadInt(int iOffset = 0)
void BaseMemory::WriteInt(any iByte, int iOffset = 0,  int flags = MemoryEx_NoNeedAdd)

void BaseMemory::WriteData(const int[] data, int iSize, int flags = MemoryEx_NoNeedAdd)

int BaseMemory::ReadString(char[] sString, int iMaxLength) - Returns string length
void BaseMemory::WriteString(const char[] sString, bool bNull = true, int flags = MemoryEx_NoNeedAdd)
void BaseMemory::WriteUnicodeString(const char[] sString, bool bNull = true, int flags = MemoryEx_NoNeedAdd)
Pointer BaseMemory::FindPattern(Pointer base, any size, const int[] pattern, int iLength, int iOffset = 0) - return address = found address + iOffset 


3) MemoryEx/DynamicLibrary.inc - Implements functions for working with dynamic libraries

PHP Code:

void DynamicLibrary::Init()
Pointer DynamicLibrary::InitModule(const char[] sNameLibrary) - exts .so/.dll - you can omit. Instead mem.lib.InitModule("engine.dll") => mem.lib.InitModule("engine") - inc will add the necessary extension for you :)

Pointer DynamicLibrary::GetBaseAddress(const char[] sName)
int DynamicLibrary::GetModuleSize(const char[] sName)
Pointer DynamicLibrary::GetEndModule(const char[] sName)

Pointer DynamicLibrary::GetModuleHandle(const char[] name)
Pointer DynamicLibrary::GetProcAddress(const char[] sLibrary, const char[] sName) <<== https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getprocaddress

Pointer DynamicLibrary::FindPattern(const char[] sModule, const int[] sPattern, int iLength, int iOffset = 0)
Pointer DynamicLibrary::FindString(const char[] sModule, const char[] sString)
Pointer DynamicLibrary::FindUnicodeString(const char[] sModule, const char[] sString)
Pointer DynamicLibrary::FindValue(const char[] sModule, any iValue, int iNextByte = 0x2A ) // iNextByte - to help 


4) MemoryEx/ServerLibrary.inc - Work with the server [.so] / [.dll] - namely, getting the base address [for Windows only] (not needed for Linux) / Getting the server OS
5) MemoryEx/LinuxFunction.inc - Helper functions for linux => loading a list of .so libraries
6) MemoryEx/WindowsFunction.inc - Functions for Windows => Get DLL Size from PEB Header / Get Windows Version



The most interesting feature as for me -> Pointer GetModuleHandle(const char[] name) which calls and returns the result of WINAPI GetModuleHandleW through SourcePawn

What an interesting feature GetModuleHandle?

MemoryEx calls the WINAPI function GetModuleHandleW to get the Base Address of any library. What is she doing?
As you can see, the first argument it takes is the name of the library whose address you need to get, but to use GetModuleHandleW, you need a unicode string. What to do? - That's why the function MemoryEx :: WriteUnicodeString was created.
In free memory, we generate this line, indent a little [0x10] and we need to create a function that calls it, pseudo-code on ASM =>

PHP Code:

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


What does this library do?
GetModuleHandleW in server.dll is used in two cases and in all - it uses kernel32.dll as an input parameter. Therefore, we are looking for the address of this string, and you can use MemoryEx::FindString, but because it is unicode - we use MemoryEx::FindUnicodeString. After we find the address of this line - we look for where this line is used through MemoryEx::FindValue. You can also notice that the last argument in this function is the auxiliary byte 0xFF, what is it?

PHP Code:

.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 


If we analyze where this line is used, we can see that always after it comes call ds: GetModuleHandleW, i.e. the first byte = 0xFF.
And so, we found out where kernel32.dll is used - now we do the offset + 0x6 and thereby load the GetModuleHandleW address. And so, how does it look in the library? =>

PHP Code:


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)); 


Further actions are:

PHP Code:

        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) returns us the address where the last byte of the line was written and we are doing a small offset to write the function itself.
        this.SetAddr( this.WriteUnicodeString(name) + PTR(offsetForString));

        Pointer pFunc = this.GetAddr();

        // Will Implement the function from the pseudocode, which was higher
        this.WriteByte(0x68,     _,     MemoryEx_AddAfterWrite); // push
        this.WriteInt(pString,    _,     MemoryEx_AddAfterWrite); // string address
        this.WriteWord(0x15FF,    _,     MemoryEx_AddAfterWrite); // call dword ptr
        this.WriteInt(module,    _,     MemoryEx_AddAfterWrite); // Address GetModuleHandleW
        this.WriteByte(0xC3,    _,    MemoryEx_AddAfterWrite); // retn 


To make it more clear, this eventually led to this:

Result

Next, just call SDKCall and get the Base Address of any dll that interests us

PHP Code:

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

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


Descriptions of some functions:

GetModuleHandle/InitModule/GetBaseAddress/GetModuleSize/GetEndModule

Pointer GetModuleHandle(const char[] library) - Returns the Base Address of the specified module [Based WINAPI GetModuleHandleW]. "0" - Returns the address of srcds.

Pointer InitModule(const char[] library) - Initializes the Base/End address of the specified module

Pointer GetBaseAddress(const char[] library) - Returns Base Address from an initialized module

int GetModuleSize(const char[] library) - Returns the initialized module size

Pointer GetEndModule(const char[] library) - Returns the address of the last initialized byte of the module [MemoryEx::GetBaseAddress + MemoryEx::GetBaseAddres]

Example:

PHP Code:

#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);
} 


Result

Examples of using

1) Inject .dll through SourcePawn [GetProcAddress + call WINAPI LoadLibraryA]

PHP Code:

#include <MemoryEx>
public void OnPluginStart()
{
    MemoryEx mem;

    if(!mem.Init()) return;

    mem.InitModule("kernel32.dll");    
    Pointer libAddr = mem.GetProcAddress("kernel32.dll", "LoadLibraryA");

    StartPrepSDKCall(SDKCall_Static);
    PrepSDKCall_AddParameter(SDKType_String, SDKPass_Pointer);
    PrepSDKCall_SetAddress(libAddr);
    PrepSDKCall_SetReturnInfo(SDKType_PlainOldData, SDKPass_Plain);

    Handle h = EndPrepSDKCall();
    int baseDLL = SDKCall(h, "D:/CSS_HOOK.dll");

    delete h;
    PrintToServer("libaddr = 0x%X Base Address DLL = 0x%X ",libAddr, baseDLL);
} 


Result

What will my plugin `bypass nobots` look like if I will code it for a given library?

Sometimes in the plugin - it is necessary to update the gamedate. Now we can just find the necessary word and "destroy it"

PHP Code:

#include <MemoryEx>
public void OnPluginStart()
{
    MemoryEx mem;
    mem.Init();
    Pointer pStr = mem.lib.FindString("server", "-nobots");
        
    if(pStr != nullptr)
    {
        mem.mem.SetAddr(pStr + PTR(0x01)); // bypass `-`
        for(int y = 0; y < 6; y++)    mem.mem.WriteByte(GetRandomInt(0x61, 0x7A), y);
    }
} 


Another way is through MemoryEx::FindPattern

PHP Code:

#include <MemoryEx>

public void OnPluginStart()
{
    static int pattern[8] = {0x2D, 0x6E, 0x6F, 0x62, 0x6F, 0x74, 0x73, 0x00}; // `-nobots`;

    MemoryEx mem;
    mem.Init();

    ModuleInfo server;

    server.base = mem.lib.GetBaseAddress("server");
    server.size = mem.lib.GetModuleSize("server");

    Pointer pStr = mem.mem.FindPattern(server.base, server.size, pattern, sizeof(pattern), 0x01); // bypass `-`

    if(pStr != nullptr)
    {
        mem.mem.SetAddr(pStr);
        for(int y = 0; y < 6; y++)    mem.mem.WriteByte(GetRandomInt(0x61, 0x7A), y);
    }
} 


[backwards]

Nice release, very useful.

[milutinke]

Nice, good job

[Rostu]

Now MemoryEx is not in one file, but in different files, which you can use separately.

MemoryEx.inc
    DynamicLibrary.inc
        ASM_Instruction.inc
        ServerLibrary.inc
            BaseMemory.inc
            WindowsFunction.inc
            LinuxFunction.inc
            Stocks.inc

Linux support has been added, as well as support for all Source Games [Windows supports Only CS: GO]

In MemoryEx/LinuxFunction.inc function LinuxParseMapsFile() - returns a StringMap that contains

1) Library name
2) Base Address
3) Initialized size

On SourcePawn - it looks like this

PHP Code:

enum struct ModuleInfo
{
    Pointer base;
    int size;
} 


Function ModifBytes was remove - which helped to restore all changed bytes during work
Now you can omit extension [Except DynamicLibrary::GetModuleHandle]

Before

PHP Code:

mem.lib.InitModule(GetServerOS() == OS_Windows ? "engine.dll" : "engine.so"); 


After

PHP Code:

mem.lib.InitModule("engine"); 


The GetServerOS function has been optimized - now upon its first call - the OS is determined - in the subsequent - the result is simply returned.

Now there is no need for MemoryEx to do MemoryEx::Init to determine the base address of the server.dll / server.so library

For Windows

PHP Code:

Pointer base = GetServerDLLBase();
int size = GetServerDLLSize() 


For Linux - everything in LinuxParseMapsFile

[EmeraldGhost]

With this module, we may no longer update gamedata after each game update
Nice release !!

[sapphonie]

Yo, does this still work? Doesn't seem to currently for TF2 on linux.

Edit: https://github.com/dragokas/Memory-Extended

[Dragokas]

sapphonie, I created a separate topic about fork:
https://forums.alliedmods.net/showthread.php?t=337502

The author is not much active under this project at the moment.

Please, ask what problems do you have (with detailed description and sample plugin) in the above topic.
Thank you.