Was zum Beispiel passieren könnte, so dass deine Annahmen komplett falsch sind:
http://en.wikipedia.org/wiki/Address_space_layout_randomization

Wie durchsuchst du eigentlich den Speicher? Ich hätte erwartet, dass das sofort abstürzt, denn deine Annahmen und Erklärungen klingen wild. was ist zum Beispiel der unterschied zwischen dem Code der Funktion und dem ausführbaren Code? Und bitweise Kopien? Ojeh! Irgendwie kann ich nicht glauben, dass du Assembler kannst und trotzdem so etwas schreibst. Verkackerst du uns?

#include <iostream>
#include <winsock2.h>
#include <windows.h>
#include <string>
#include "C:\\Users\\HA_0xFF\\Desktop\\C++\\Memory\\Memory\\WMemory.h"
#pragma comment(lib,"ws2_32.lib")
using namespace std;
const bool cmpbits(unsigned char b,unsigned char bb)
	{
		unsigned long x1=0;
		x1=x1|b;
		unsigned long x2=0;
		x2=x2|bb;
		if(x1==x2)
			return true;
		return false;
	}
const bool SearchFunktionWithBitmask(const unsigned long startaddr, MemStr t_cpy_bitmask, unsigned long *ULAddress)
{
	*ULAddress=0;
	unsigned long startaddress;
	unsigned long tempaddr;
	unsigned long endaddress;
	if(startaddr==0)
	{
		SYSTEM_INFO sys;
		GetSystemInfo(&sys);
		tempaddr=0x40000000;
		startaddress=reinterpret_cast<unsigned long>(sys.lpMinimumApplicationAddress);
		endaddress=reinterpret_cast<unsigned long>(sys.lpMaximumApplicationAddress);
	}
	else
	{
        SYSTEM_INFO sys;
		GetSystemInfo(&sys);
		startaddress=startaddr;
		endaddress=reinterpret_cast<unsigned long>(sys.lpMaximumApplicationAddress);
		tempaddr=startaddress;
	}
	MEMORY_BASIC_INFORMATION mbi;
	unsigned char *readptr;
	do
	{
		VirtualQuery(reinterpret_cast<void*>(tempaddr),&mbi,sizeof(MEMORY_BASIC_INFORMATION));
		unsigned long start=reinterpret_cast<unsigned long>(mbi.BaseAddress);

		unsigned long end=reinterpret_cast<unsigned long>(mbi.BaseAddress)+mbi.RegionSize;
if(mbi.State==MEM_COMMIT)
{
        for(unsigned long x=start;x<end;x++)
		{
			unsigned long fail=0;
			readptr=reinterpret_cast<unsigned char*>(x);
			for(unsigned long n=0;n<t_cpy_bitmask.GetLength();n++)
			{
				if(cmpbits(*readptr,t_cpy_bitmask[n])==false)
				{
					fail++;
					break;
				}
				readptr++;
			}
			if(fail==0)
			{

				*ULAddress=x;
				return true;

			}

		}
}
tempaddr+=mbi.RegionSize;
	}while((tempaddr<endaddress)&&(*ULAddress==0));

}
const MemStr CreateFunctionBitmask(const unsigned long addroffunc, unsigned long SizeOfByteWritesToBitmask)
{
	MemStr mem;
	mem="";

	unsigned char *Func=(unsigned char*)addroffunc;
	for(unsigned long x=0;x<SizeOfByteWritesToBitmask;x++)
	{
		mem[x]=0;
		mem[x]=mem[x]|(*Func&1);
		mem[x]=mem[x]|(*Func&2);
		mem[x]=mem[x]|(*Func&4);
		mem[x]=mem[x]|(*Func&8);
		mem[x]=mem[x]|(*Func&16);
		mem[x]=mem[x]|(*Func&32);
		mem[x]=mem[x]|(*Func&64);
		mem[x]=mem[x]|(*Func&128);
        Func++;
	}
	mem.SetLength(SizeOfByteWritesToBitmask-1);
	return mem;
}
void ShowBits(unsigned char bit)
{
	cout<<((bit&1)==1?1:0);
    cout<<((bit&2)==2?1:0);
	cout<<((bit&4)==4?1:0);
	cout<<((bit&8)==8?1:0);
	cout<<" "<<((bit&16)==16?1:0);
	cout<<((bit&32)==32?1:0);
	cout<<((bit&64)==64?1:0);
	cout<<((bit&128)==128?1:0)<<endl;
}
typedef int (_stdcall *Proc)(SOCKET s,const char *send,int len,int flag);
int main()
{     
	    //Erstelle Bitmask von der Funktion WSAStartup
	MemStr ss=CreateFunctionBitmask((unsigned long)&WSAStartup,4000);
   unsigned long addr;
   //Durchsuche den Ram nach WSAStartup
   SearchFunktionWithBitmask(0x40000000,ss,&addr);
   cout<<"0x"<<(unsigned*)addr<<endl;
   cout<<"0x"<<&WSAStartup<<endl;

	system("Pause");
	return 0;
}

Falls ich die Addresse ab der ich Anfange nach der Funktion zu suchen selbst setze finde ich immer mehrere Ergebnisse