VOID SendCommandToConsole( CHAR* szCommand )
{
	DWORD dwSend = (DWORD)0x004D3EA0;  // Die Adresse von SendCommandToConsole
 
	_asm push	szCommand // Wir pushen unseren Command, bzw die Adresse, auf den Stack
	_asm push	0 // Wir pushen eine null auf den Stack (Verwendung unbekannt)
	_asm call	dwSend // Da wir alle erforderlichen Sachen auf dem Stack haben wird die Funktion angesprungen
	_asm add	esp, 0x8 // Und es wird der Stack gefixxt
}

[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
 
const uint PAGE_EXECUTE_READWRITE = 0x40;
const uint MEM_COMMIT = 0x1000;
 
public static bool AddFunction(String sFunctionName, byte[] arFunctionCode)
        {
             // Die Klasse hat keinen Konstruktor da statisch
             // Also wird bei der ersten Verwendung das Dictionary angelegt
            if (dicFunctions == null)
                dicFunctions = new Dictionary();
 
            // Wenn diese Funktion noch nicht in der Liste ist...
            if (dicFunctions.ContainsKey(sFunctionName))
                return false;
 
            // Wir reservieren den Speicher für exakt diese Codelänge
            IntPtr ptrResult = VirtualAlloc(IntPtr.Zero, (uint)arFunctionCode.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
            // Und kopieren den Code an die Stelle
            Marshal.Copy(arFunctionCode, 0, ptrResult, arFunctionCode.Length);
 
            // Debugausgaben sind was schönes :D
            MessageBox.Show("Located at " + ptrResult.ToString("x"));
            // Schließlich wird der Pointer zu der Funktion dem Dictionary
            // in Abhänigkeit von dem Namen zugeordnet
            dicFunctions.Add(sFunctionName, ptrResult);
 
            return true;
        }

// In ASMHelper
public static T GetFunction(String sFunctionName) where T : class
        {
            return MemoryHelper.GetFunctionFromAddress(dicFunctions[sFunctionName]);
        }
 
// In Main
private delegate void VoidReturner(); // Ein Delegate vom Type VOID
 
ASMHelper.AddFunction("ConsoleSend", arFinal); // Wir adden den Code zum Dictionary
// Holen es und als eine Funktion vom Type VOID
VoidReturner SendToConsole = ASMHelper.GetFunction("ConsoleSend");
// Und so wirds dann aufgerufen!
SendToConsole();

// Command in unmanaged Speicher kopieren:
// Der Command dass sich die Bots nicht mehr bewegen
byte[] Begin = Encoding.ASCII.GetBytes("testclients_domove 0");
 
// Speicher dafür reservieren
IntPtr TempPtr = VirtualAlloc(IntPtr.Zero, (uint)Begin.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
// Das Byte-Array mit dem Command an den reservierten Ort kopieren
Marshal.Copy(Begin, 0, TempPtr, Begin.Length);
 
// Und schließlich diesen Zeiger auf den Command in ein Byte[4] umwandeln.
byte[] TempAddress = BitConverter.GetBytes(TempPtr.ToInt32());
 
// Die OpCodes bilden:
byte[] arFinal = {0xb8, TempAddress[0],TempAddress[1],TempAddress[2],TempAddress[3], // mov eax, TempPtr
                                     0x50, // PUSH EAX
                                     0x6A, 0x00, // PUSH 0
                                     0xB8, 0xA0,0x3E,0x4D,0x00, // mov eax, 0x004D3EA0
                                     0xFF, 0xD0, // CALL EAX
                                     0x83, 0xC4, 0x08, // ADD ESP 0x08
                                     0xC3 // RET
                                 };