(btw, schau mal nach, ob die Dateien main.c und procfunc.c auch wirklich in deinem Projektverzeichnis liegen)

So jetzt hab ich neue fehler

------ Erstellen gestartet: Projekt: DMA HÄXXN, Konfiguration: Debug Win32 ------
Kompilieren...
main.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\main.c(2) : fatal error C1083: Datei (Include) kann nicht geöffnet werden: "resource.h": No such file or directory
procfunc.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\procfunc.c(2) : fatal error C1083: Datei (Include) kann nicht geöffnet werden: "procfunc.h": No such file or directory
Code wird generiert...
Das Buildprotokoll wurde unter "file://c:\Dokumente und Einstellungen\keller\Desktop\Neuer Ordner\DMA_HÄXXN___Win32_Debug\BuildLog.htm" gespeichert.
DMA HÄXXN - 2 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

So da hab ich aber nichts mit #inlcude...

//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by rsrc.rc
//
#define IDD_DLGMAIN                     1000
#define IDC_ABOUT                       1001
#define IDC_EXIT                        1002
#define IDC_STATUSTEXT                  1003
#define IDC_KEY0                        1010
#define IDC_KEY1                        1011
#define IDC_KEY2                        1012
#define IDC_KEY3                        1013
#define IDC_KEY4                        1014
#define IDC_KEY5                        1015
#define IDC_KEY6                        1016
#define IDC_KEY7                        1017
#define IDC_KEY8                        1018
#define IDC_KEY9                        1019
#define IDC_KEYPB                       1030
#define IDC_KEYZM                       1031
#define IDC_KEYDH                       1032
#define IDC_KEYZM2                      1033
#define IDC_KEYZM3                      1035
#define IDC_STAT0                       1100
#define IDC_STAT1                       1101
#define IDC_STAT2                       1102
#define IDC_STAT3                       1103
#define IDC_STAT4                       1104
#define IDC_STAT5                       1105
#define IDC_STAT6                       1106
#define IDC_STAT7                       1107
#define IDC_STAT8                       1108
#define IDC_STAT9                       1109
#define IDC_STATPB                      1130
#define IDC_STATZM                      1131
#define IDC_STATZM2                     1132
#define IDC_NAME0                       1200
#define IDC_NAME1                       1201
#define IDC_NAME2                       1202
#define IDC_NAME3                       1203
#define IDC_NAME4                       1204
#define IDC_NAME5                       1205
#define IDC_NAME6                       1206
#define IDC_NAME7                       1207
#define IDC_NAME8                       1208
#define IDC_NAME9                       1209
#define IDC_NAMEPB                      1230
#define IDC_NAMEZM                      1231
#define IDC_NAMEDH                      1232

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        107
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1024
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

Und das ist procfunc.h

#pragma once

BOOL  Peek(HANDLE gamePROC,DWORD Address, DWORD Count,void * save);
BOOL Poke(HANDLE gamePROC,DWORD Address, LPVOID write, DWORD Count);
DWORD GetPID(char *ExeName);
DWORD GetDLLBase(DWORD pid,char* DllName);
BOOL InjectDLL(LPCTSTR sLibName,DWORD dwProcID);
BOOL EjectDLL(LPCTSTR sLibName,DWORD dwProcID);
BOOL MemCopyEx(HANDLE hProcess,DWORD dwFrom,DWORD dwTo,DWORD dwSize);
DWORD CreateCopy(DWORD dwBase, DWORD dwSize);
DWORD CreateCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize);
BOOL DeleteCopy(DWORD dwBase, DWORD dwSize);
BOOL DeleteCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize);
BOOL LoadSeDebugPrivilege();

#include <windows.h>
#include <procfunc.h>
#include <tlhelp32.h>
/

BOOL Peek(HANDLE gamePROC,DWORD Address, DWORD Count,void * save){
// Diese Function Liest aus dem Speicher des Prozesses "proc" ab der Addresse "Address"
// "Count" Bytes und speichert diese in "save". Wenn alles erfolgreich ist wird TRUE übergeben
UINT iRPM;
DWORD pStateOld, pStateDummy;
DWORD bw; // var für RPM

iRPM = 0;
if (gamePROC != 0){// Wenn gefunden
//rechte im Speicher auf ALL_ACCESS
if (VirtualProtectEx(gamePROC,(PDWORD)(Address),Count,PAGE_READWRITE,&pStateOld)){
// Ab Address Bytes lesen
iRPM = ReadProcessMemory(gamePROC, (PDWORD)(Address),save, Count, &bw);
//rechte im Speicher wieder standard
VirtualProtectEx(gamePROC,(PDWORD)(Address),Count,pStateOld,&pStateDummy);
}
}
return ((iRPM!=0)&(bw==Count));
}

BOOL Poke(HANDLE gamePROC,DWORD Address, void *write, DWORD Count){
// Diese Function schreibt in den Speicher des Prozesses "proc" ab der Addresse "Address"
// "write".Count ist die große in Bytes. Wenn alles erfolgreich ist wird TRUE übergeben
UINT iWPM;
DWORD pStateOld, pStateDummy;
DWORD bw; // var für WPM
MEMORY_BASIC_INFORMATION mbi;

iWPM = 0;
if (gamePROC != 0){// Wenn gefunden
//Information über den gewählten Speicherbereich holen
VirtualQueryEx(gamePROC,(PDWORD)Address,&mbi,sizeof(MEMORY_BASIC_INFORMATION));
//rechte im Speicherbereich auf READWRITE
if (VirtualProtectEx(gamePROC,(PDWORD)mbi.BaseAddress,mbi.RegionSize,PAGE_READWRITE,&pStateOld)){
// Ab Address Bytes schreiben wenn Rechte erfolgreich gesetzt
iWPM = WriteProcessMemory(gamePROC, (PDWORD)(Address),write, Count, &bw);
//rechte im Speicherbereich wieder standard
VirtualProtectEx(gamePROC,(PDWORD)mbi.BaseAddress,mbi.RegionSize,pStateOld,&pStateDummy);
}

}
return (bw==Count);
}

DWORD GetPID(char *ExeName){
// Diese Funktion gibt die ProzessID von "EXEName" in der Prozessliste zurück
HANDLE snapProc;
PROCESSENTRY32 pe32;

// Prozess finden
snapProc = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
if(snapProc == INVALID_HANDLE_VALUE) return 0; // Wenn kein gültiges Suchhandle dann Funktionsabbruch
pe32.dwSize = sizeof(PROCESSENTRY32); // Informationen Initialisieren
if(Process32First(snapProc,&pe32)){ // Wenn 1. Prozess gefunden
do{ // Schleifen anfang
if (stricmp(ExeName,pe32.szExeFile)==0){; // Ist Prozess.Exename = BF2 dann
CloseHandle(snapProc); // Suchhandle schließen
return pe32.th32ProcessID; // ProcessID übergeben und Funktion beenden
}
} while(Process32Next(snapProc,&pe32));
} //Sleife solange Prozesse gefunden werden
CloseHandle(snapProc); // Suchhandle schließen
return 0;
}

DWORD GetDLLBase(DWORD pid,char* DllName){
//Diese Function liest die Base Addresse des Moduls "DLLName" aus dem Prozess mit der ID "pid"
HANDLE snapMod;
MODULEENTRY32 me32;

// Modul im Prozess finden
snapMod = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid); //Suchhandle auf alle Module im Process iProcID
me32.dwSize = sizeof(MODULEENTRY32); // Informationen vorbereiten
if (Module32First(snapMod, &me32)){ // Erstes Modul finden und informationen speichern
do{ // Solange noch module gefunden werden
if (stricmp(DllName,me32.szModule) == 0){ // Wenn aktuell gefundenes Modul.Name mit übergebenem DLLName übereinstimmt
CloseHandle(snapMod); //Suchhandle schließen
return (DWORD) me32.modBaseAddr; // Dll Base Addresse speichern
}
}while(Module32Next(snapMod,&me32));
}
// Hier kommt man nur an wenn das Modul nicht gefunden wurde
CloseHandle(snapMod); // Suchhandle schließen
return 0; // 0 übergeben
}

BOOL InjectDLL(LPCTSTR sLibName,DWORD dwProcID){
// Diese Function Injeziert ein Modul "sLibName" in den Prozess mit der ID "dwProcID"
// Wenn erfolgreich injeziert wird TRUE übergeben
DWORD dwLLA,dwTID,dwMemSize,dwTargetMemory,hMod;
HANDLE hProc,hThread;
char fullLibName[MAX_PATH];

// Wenn die DLL bereits im Prozess Procedure beenden
if (GetDLLBase(dwProcID,(char *)sLibName)!=0) return TRUE;
// Prozess öffnen mit vollzugriff
hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
if (!hProc){
return FALSE;
}
// kompletter Pfad und dateiname ermitteln
if (SearchPath(NULL,sLibName,NULL,MAX_PATH,fullLibName,0)){
// Größe des vollen Dll-Namens ermitteln

dwMemSize = strlen(fullLibName)+1;
}else return FALSE;
// Speicher im Game für DllName reservieren
dwTargetMemory = (DWORD) VirtualAllocEx(hProc,NULL,dwMemSize,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
// Addresse der Function LoadLibrary ermitteln
dwLLA = (DWORD) GetProcAddress(GetModuleHandleA("kernel32.dll"),"LoadLibraryA");
// Wenn Addresse gefunden und Speicher allokiert
if ((dwLLA!=0) & (dwTargetMemory!=0)){
// Modulname in Prozess schreiben
Poke(hProc,dwTargetMemory,(void *)fullLibName,dwMemSize);
// Thread im Process Prozess starten der LoadLibrary ausführt
hThread = CreateRemoteThread(hProc,NULL,0, (void *)dwLLA,(void *)dwTargetMemory,0,&dwTID);
// auf den Thread warten bis er fertig ist
WaitForSingleObject(hThread,INFINITE);
// LoadLibrary erfolgreich?
GetExitCodeThread(hThread,&hMod);
// Handle des Threads schließen
CloseHandle(hThread);
}
// Speicher und Handles schließen
if (dwTargetMemory) VirtualFreeEx(hProc,(PDWORD)dwTargetMemory,dwMemSize,MEM_DECOMMIT);
if (hProc)CloseHandle(hProc);
// Wenn DLL in Prozess TRUE übergeben
if (GetDLLBase(dwProcID,(char *)sLibName)!=0) return TRUE;
return FALSE;
}

BOOL EjectDLL(LPCTSTR sLibName,DWORD dwProcID){
// Diese Function Entlädt das Modul "sLibName" in den Prozess mit der ID "dwProcID"
// Wenn erfolgreich entladen wird TRUE übergeben
DWORD dwFL,dwTID;
PBYTE dwModuleHandle = 0;
DWORD dwCRTResult;
HANDLE hProc,hThread;

// DLLBase (DWORD) als PBYTE schreiben
dwModuleHandle=(PBYTE) GetDLLBase(dwProcID,(char *)sLibName);
// Wenn die DLL bereits im Prozess beendet
if (!dwModuleHandle) return TRUE;
// Prozess öffnen mit vollzugriff
hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
if (!hProc) return FALSE;

// Addresse der Function FreeLibrary ermitteln
dwFL = (DWORD) GetProcAddress(GetModuleHandleA("kernel32.dll"),"FreeLibrary");
if ((dwFL) && (dwModuleHandle)){
// Thread im Process Prozess starten der LoadLibrary ausführt
hThread = CreateRemoteThread(hProc,NULL,0, (void )dwFL,(void)dwModuleHandle,0,&dwTID);
// auf den Thread warten bis er fertig ist
WaitForSingleObject(hThread,INFINITE);
// Ergebnis
GetExitCodeThread(hThread,&dwCRTResult);
// Handle des Threads schließen
CloseHandle(hThread);
}
// Speicher und Handles schließen
if (hProc)CloseHandle(hProc);
// Wenn DLL in Prozess TRUE übergeben
if (!GetDLLBase(dwProcID,(char *)sLibName)) return TRUE;
return FALSE;
}

BOOL MemCopyEx(HANDLE hProcess,DWORD dwFrom,DWORD dwTo,DWORD dwSize){
// Diese Function kopiert im Prozess "hProcess" den Bereich ab "dwFrom" mit der
// größe "dwSize" an die Addresse "dwTo" und übergibt TRUE wenn erfolgreich

//Speicher für Buffer reservieren
PBYTE dwBuffer = (PBYTE)VirtualAlloc(0,dwSize,MEM_COMMIT,PAGE_READWRITE);
// Lesen und Zweischenspeichern
if (Peek(hProcess,dwFrom,dwSize,dwBuffer)){
// Zwischenspeicher schreiben
if (Poke(hProcess,dwTo,dwBuffer,dwSize)){
// Zwischenspeicher leeren
VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
// Function beenden
return TRUE;
}
}
// Zwischenspeicher leeren
VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
return FALSE;
}

DWORD CreateCopy(DWORD dwBase, DWORD dwSize){
// Diese Function kopiert im aktuellen Prozess den Bereich "dwBase" mit der größe "dwSize"
// und übergibt wenn erfolgreich die Addresse an die es kopiert worden ist

//Speicher für Buffer reservieren
PBYTE dwBuffer = (PBYTE)VirtualAlloc(0,dwSize,MEM_COMMIT,PAGE_READWRITE);
if (!dwBuffer) return 0;
//Speicher lesen und speichern
if (Peek(GetCurrentProcess(),dwBase,dwSize,dwBuffer)){
// Zwischenspeicher leeren
VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
// Addresse des gespeicherten zurückgeben
return (DWORD) dwBuffer;
}
// Zwischenspeicher leeren
VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
return 0;
}

DWORD CreateCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize){
// Diese Function kopiert im Prozess "hProcess" den Bereich "dwBase" mit der größe "dwSize"
// und übergibt wenn erfolgreich die Addresse an die es kopiert worden ist
DWORD dwBufferAddr;

//Speicher für Buffer reservieren
dwBufferAddr = (DWORD) VirtualAllocEx(hProcess,0,dwSize,MEM_COMMIT,PAGE_READWRITE);
if (!dwBufferAddr) return 0;
//Speicher kopieren
if (MemCopyEx(hProcess,dwBase,dwBufferAddr,dwSize)){
return (DWORD) dwBufferAddr;
}
// Zwischenspeicher leeren
return 0;
}

BOOL DeleteCopy(DWORD dwBase, DWORD dwSize){
return VirtualFree((PDWORD) dwBase,dwSize, MEM_RELEASE);
}

BOOL DeleteCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize){
return VirtualFreeEx(hProcess,(PDWORD) dwBase,dwSize, MEM_DECOMMIT);
}

BOOL LoadSeDebugPrivilege(){
HANDLE hToken;
LUID Val;
TOKEN_PRIVILEGES tp;

if (!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
return(FALSE);
if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Val))
return(FALSE);
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = Val;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL))
return(FALSE);
CloseHandle(hToken);
return TRUE;
}

void HideModule(HINSTANCE hModule)
{
DWORD dwPEB_LDR_DATA = 0;
_asm
{
pushad;
pushfd;
mov eax, fs:[30h] // PEB
mov eax, [eax+0Ch] // PEB->ProcessModuleInfo
mov dwPEB_LDR_DATA, eax // Save ProcessModuleInfo

InLoadOrderModuleList:
mov esi, [eax+0Ch] // ProcessModuleInfo->InLoadOrderModuleList[FORWARD]
mov edx, [eax+10h] // ProcessModuleInfo->InLoadOrderModuleList[BACKWARD]

LoopInLoadOrderModuleList:
lodsd // Load First Module
mov esi, eax // ESI points to Next Module
mov ecx, [eax+18h] // LDR_MODULE->BaseAddress
cmp ecx, hModule // Is it Our Module ?
jne SkipA // If Not, Next Please (@f jumps to nearest Unamed Lable @@:)
mov ebx, [eax] // [FORWARD] Module
mov ecx, [eax+4] // [BACKWARD] Module
mov [ecx], ebx // Previous Module's [FORWARD] Notation, Points to us, Replace it with, Module++
mov [ebx+4], ecx // Next Modules, [BACKWARD] Notation, Points to us, Replace it with, Module--
jmp InMemoryOrderModuleList // Hidden, so Move onto Next Set
SkipA:
cmp edx, esi // Reached End of Modules ?
jne LoopInLoadOrderModuleList // If Not, Re Loop

InMemoryOrderModuleList:
mov eax, dwPEB_LDR_DATA // PEB->ProcessModuleInfo
mov esi, [eax+14h] // ProcessModuleInfo->InMemoryOrderModuleList[START]
mov edx, [eax+18h] // ProcessModuleInfo->InMemoryOrderModuleList[FINISH]

LoopInMemoryOrderModuleList:
lodsd
mov esi, eax
mov ecx, [eax+10h]
cmp ecx, hModule
jne SkipB
mov ebx, [eax]
mov ecx, [eax+4]
mov [ecx], ebx
mov [ebx+4], ecx
jmp InInitializationOrderModuleList
SkipB:
cmp edx, esi
jne LoopInMemoryOrderModuleList

InInitializationOrderModuleList:
mov eax, dwPEB_LDR_DATA // PEB->ProcessModuleInfo
mov esi, [eax+1Ch] // ProcessModuleInfo->InInitializationOrderModuleList[START]
mov edx, [eax+20h] // ProcessModuleInfo->InInitializationOrderModuleList[FINISH]

LoopInInitializationOrderModuleList:
lodsd
mov esi, eax
mov ecx, [eax+08h]
cmp ecx, hModule
jne SkipC
mov ebx, [eax]
mov ecx, [eax+4]
mov [ecx], ebx
mov [ebx+4], ecx
jmp Finished
SkipC:
cmp edx, esi
jne LoopInInitializationOrderModuleList

Finished:
popfd;
popad;
}
}[/cpp]

So jetzt hab ich es richitg.Es soll zwar ein hack werden aber nur für Singelplayer.

#include <windows.h>
#include <procfunc.h>
#include <tlhelp32.h>
/

BOOL  Peek(HANDLE gamePROC,DWORD Address, DWORD Count,void * save){
// Diese Function Liest aus dem Speicher des Prozesses "proc" ab der Addresse "Address"
// "Count" Bytes und speichert diese in "save". Wenn alles erfolgreich ist wird TRUE übergeben
  UINT iRPM;
  DWORD pStateOld, pStateDummy;
  DWORD bw;   //  var für RPM

  iRPM = 0;
  if (gamePROC != 0){// Wenn gefunden
    //rechte im Speicher auf ALL_ACCESS
	if (VirtualProtectEx(gamePROC,(PDWORD)(Address),Count,PAGE_READWRITE,&pStateOld)){
	  // Ab Address Bytes lesen
      iRPM = ReadProcessMemory(gamePROC, (PDWORD)(Address),save, Count, &bw);
      //rechte im Speicher wieder standard
	  VirtualProtectEx(gamePROC,(PDWORD)(Address),Count,pStateOld,&pStateDummy);
	}
  }
  return ((iRPM!=0)&(bw==Count));
}

BOOL Poke(HANDLE gamePROC,DWORD Address, void *write, DWORD Count){
// Diese Function schreibt in den Speicher des Prozesses "proc" ab der Addresse "Address"
// "write".Count ist die große in Bytes. Wenn alles erfolgreich ist wird TRUE übergeben
  UINT iWPM;
  DWORD pStateOld, pStateDummy;
  DWORD bw;   //  var für WPM
  MEMORY_BASIC_INFORMATION mbi;

  iWPM = 0;
  if (gamePROC != 0){// Wenn gefunden
	//Information über den gewählten Speicherbereich holen
	VirtualQueryEx(gamePROC,(PDWORD)Address,&mbi,sizeof(MEMORY_BASIC_INFORMATION));
	//rechte im Speicherbereich auf READWRITE
	if (VirtualProtectEx(gamePROC,(PDWORD)mbi.BaseAddress,mbi.RegionSize,PAGE_READWRITE,&pStateOld)){
	   // Ab Address Bytes schreiben wenn Rechte erfolgreich gesetzt
       iWPM = WriteProcessMemory(gamePROC, (PDWORD)(Address),write, Count, &bw);
       //rechte im Speicherbereich wieder standard
	   VirtualProtectEx(gamePROC,(PDWORD)mbi.BaseAddress,mbi.RegionSize,pStateOld,&pStateDummy);
	}

  }
  return (bw==Count);
}

DWORD GetPID(char *ExeName){
// Diese Funktion gibt die ProzessID von "EXEName" in der Prozessliste zurück
  HANDLE snapProc;  
  PROCESSENTRY32 pe32;

  // Prozess finden
  snapProc = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  if(snapProc == INVALID_HANDLE_VALUE) return 0; // Wenn kein gültiges Suchhandle dann Funktionsabbruch
  pe32.dwSize = sizeof(PROCESSENTRY32);  // Informationen Initialisieren
  if(Process32First(snapProc,&pe32)){  // Wenn 1. Prozess gefunden
	do{  // Schleifen anfang 
       if (stricmp(ExeName,pe32.szExeFile)==0){; // Ist Prozess.Exename = BF2 dann
	      CloseHandle(snapProc);   // Suchhandle schließen
		  return pe32.th32ProcessID;  // ProcessID übergeben und Funktion beenden
	   }
	} while(Process32Next(snapProc,&pe32));
  } //Sleife solange Prozesse gefunden werden 
  CloseHandle(snapProc);   // Suchhandle schließen
  return 0;
}

DWORD GetDLLBase(DWORD pid,char* DllName){
//Diese Function liest die Base Addresse des Moduls "DLLName" aus dem Prozess mit der ID "pid"
  HANDLE snapMod;  
  MODULEENTRY32 me32;

  // Modul im Prozess finden
  snapMod = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);  //Suchhandle auf alle Module im Process iProcID
  me32.dwSize = sizeof(MODULEENTRY32);   // Informationen vorbereiten
  if (Module32First(snapMod, &me32)){   // Erstes Modul finden und informationen speichern
    do{   // Solange noch module gefunden werden
        if (stricmp(DllName,me32.szModule) == 0){  // Wenn aktuell gefundenes Modul.Name mit übergebenem DLLName übereinstimmt
          CloseHandle(snapMod);  //Suchhandle schließen
          return (DWORD) me32.modBaseAddr;  // Dll Base Addresse speichern
        }
    }while(Module32Next(snapMod,&me32));
  }
  // Hier kommt man nur an wenn das Modul nicht gefunden wurde
  CloseHandle(snapMod); // Suchhandle schließen
  return 0;   // 0 übergeben
}

BOOL InjectDLL(LPCTSTR sLibName,DWORD dwProcID){
// Diese Function Injeziert ein Modul "sLibName" in den Prozess mit der ID "dwProcID"
// Wenn erfolgreich injeziert wird TRUE übergeben
  DWORD dwLLA,dwTID,dwMemSize,dwTargetMemory,hMod;
  HANDLE hProc,hThread;
  char fullLibName[MAX_PATH];

  // Wenn die DLL bereits im Prozess Procedure beenden
  if (GetDLLBase(dwProcID,(char *)sLibName)!=0) return TRUE;
  // Prozess öffnen mit vollzugriff
  hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
  if (!hProc){
	 return FALSE;
  }
  // kompletter Pfad und dateiname ermitteln
  if (SearchPath(NULL,sLibName,NULL,MAX_PATH,fullLibName,0)){
    // Größe des vollen Dll-Namens ermitteln 

	dwMemSize = strlen(fullLibName)+1;
  }else return FALSE;
  // Speicher im Game für DllName reservieren
  dwTargetMemory = (DWORD) VirtualAllocEx(hProc,NULL,dwMemSize,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
  // Addresse der Function LoadLibrary ermitteln
  dwLLA = (DWORD) GetProcAddress(GetModuleHandleA("kernel32.dll"),"LoadLibraryA");
  // Wenn Addresse gefunden und Speicher allokiert
  if ((dwLLA!=0) & (dwTargetMemory!=0)){
    // Modulname in Prozess schreiben
	Poke(hProc,dwTargetMemory,(void *)fullLibName,dwMemSize);
	// Thread im Process Prozess starten der LoadLibrary ausführt
	hThread = CreateRemoteThread(hProc,NULL,0, (void *)dwLLA,(void *)dwTargetMemory,0,&dwTID);
    // auf den Thread warten bis er fertig ist
	WaitForSingleObject(hThread,INFINITE);
	// LoadLibrary erfolgreich?
	GetExitCodeThread(hThread,&hMod);
	// Handle des Threads schließen
	CloseHandle(hThread);
  }
  // Speicher und Handles schließen
  if (dwTargetMemory) VirtualFreeEx(hProc,(PDWORD)dwTargetMemory,dwMemSize,MEM_DECOMMIT);
  if (hProc)CloseHandle(hProc);
  // Wenn DLL in Prozess TRUE übergeben
  if (GetDLLBase(dwProcID,(char *)sLibName)!=0) return TRUE;
  return FALSE;
}

BOOL EjectDLL(LPCTSTR sLibName,DWORD dwProcID){
// Diese Function Entlädt das Modul "sLibName" in den Prozess mit der ID "dwProcID"
// Wenn erfolgreich entladen wird TRUE übergeben
  DWORD dwFL,dwTID;
  PBYTE dwModuleHandle = 0;
  DWORD dwCRTResult;
  HANDLE hProc,hThread;

  // DLLBase (DWORD) als PBYTE schreiben
  dwModuleHandle=(PBYTE) GetDLLBase(dwProcID,(char *)sLibName);
  // Wenn die DLL bereits im Prozess beendet
  if (!dwModuleHandle) return TRUE;
  // Prozess öffnen mit vollzugriff
  hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwProcID);
  if (!hProc) return FALSE;

  // Addresse der Function FreeLibrary ermitteln
  dwFL = (DWORD) GetProcAddress(GetModuleHandleA("kernel32.dll"),"FreeLibrary");
  if ((dwFL) && (dwModuleHandle)){
    // Thread im Process Prozess starten der LoadLibrary ausführt
    hThread = CreateRemoteThread(hProc,NULL,0, (void *)dwFL,(void*)dwModuleHandle,0,&dwTID);
    // auf den Thread warten bis er fertig ist
    WaitForSingleObject(hThread,INFINITE);
    // Ergebnis
    GetExitCodeThread(hThread,&dwCRTResult);
    // Handle des Threads schließen
    CloseHandle(hThread);
  }
  // Speicher und Handles schließen
  if (hProc)CloseHandle(hProc);
  // Wenn DLL in Prozess TRUE übergeben
  if (!GetDLLBase(dwProcID,(char *)sLibName)) return TRUE;
  return FALSE;
}

BOOL MemCopyEx(HANDLE hProcess,DWORD dwFrom,DWORD dwTo,DWORD dwSize){
// Diese Function kopiert im Prozess "hProcess" den Bereich ab "dwFrom" mit der 
// größe "dwSize" an die Addresse "dwTo" und übergibt TRUE wenn erfolgreich

  //Speicher für Buffer reservieren
  PBYTE dwBuffer = (PBYTE)VirtualAlloc(0,dwSize,MEM_COMMIT,PAGE_READWRITE);
  // Lesen und Zweischenspeichern
  if (Peek(hProcess,dwFrom,dwSize,dwBuffer)){
	// Zwischenspeicher schreiben
	if (Poke(hProcess,dwTo,dwBuffer,dwSize)){
	  // Zwischenspeicher leeren
	  VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
	  // Function beenden
	  return TRUE;
    }
  }
  // Zwischenspeicher leeren
  VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
  return FALSE;
}

DWORD CreateCopy(DWORD dwBase, DWORD dwSize){
// Diese Function kopiert im aktuellen Prozess den Bereich "dwBase" mit der größe "dwSize"
// und übergibt wenn erfolgreich die Addresse an die es kopiert worden ist

  //Speicher für Buffer reservieren
  PBYTE dwBuffer = (PBYTE)VirtualAlloc(0,dwSize,MEM_COMMIT,PAGE_READWRITE);
  if (!dwBuffer) return 0;
  //Speicher lesen und speichern
  if (Peek(GetCurrentProcess(),dwBase,dwSize,dwBuffer)){
	// Zwischenspeicher leeren
	VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
	// Addresse des gespeicherten zurückgeben
	return (DWORD) dwBuffer;
  }
  // Zwischenspeicher leeren
  VirtualFree(dwBuffer,dwSize,MEM_RELEASE);
  return 0;
}

DWORD CreateCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize){
// Diese Function kopiert im Prozess "hProcess" den Bereich "dwBase" mit der größe "dwSize"
// und übergibt wenn erfolgreich die Addresse an die es kopiert worden ist
  DWORD dwBufferAddr;

  //Speicher für Buffer reservieren
  dwBufferAddr = (DWORD) VirtualAllocEx(hProcess,0,dwSize,MEM_COMMIT,PAGE_READWRITE);
  if (!dwBufferAddr) return 0;
  //Speicher kopieren
  if (MemCopyEx(hProcess,dwBase,dwBufferAddr,dwSize)){
    return (DWORD) dwBufferAddr;
  }
  // Zwischenspeicher leeren
  return 0;
}

BOOL DeleteCopy(DWORD dwBase, DWORD dwSize){
 return VirtualFree((PDWORD) dwBase,dwSize, MEM_RELEASE);
}

BOOL DeleteCopyEx(HANDLE hProcess, DWORD dwBase, DWORD dwSize){
 return VirtualFreeEx(hProcess,(PDWORD) dwBase,dwSize, MEM_DECOMMIT);
}

BOOL LoadSeDebugPrivilege(){
  HANDLE hToken;
  LUID Val;
  TOKEN_PRIVILEGES tp;

  if (!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
     return(FALSE);
  if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Val))
     return(FALSE);
  tp.PrivilegeCount = 1;
  tp.Privileges[0].Luid = Val;
  tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  if (!AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL))
	 return(FALSE);
  CloseHandle(hToken);
  return TRUE;
}

void HideModule(HINSTANCE hModule)
{
	DWORD dwPEB_LDR_DATA = 0;
	_asm
	{
		pushad;
		pushfd;
		mov eax, fs:[30h]		   // PEB
		mov eax, [eax+0Ch]		  // PEB->ProcessModuleInfo
		mov dwPEB_LDR_DATA, eax	 // Save ProcessModuleInfo

InLoadOrderModuleList:
		mov esi, [eax+0Ch]					  // ProcessModuleInfo->InLoadOrderModuleList[FORWARD]
		mov edx, [eax+10h]					  //  ProcessModuleInfo->InLoadOrderModuleList[BACKWARD]

		LoopInLoadOrderModuleList: 
		    lodsd							   //  Load First Module
			mov esi, eax		    			//  ESI points to Next Module
			mov ecx, [eax+18h]		    		//  LDR_MODULE->BaseAddress
			cmp ecx, hModule		    		//  Is it Our Module ?
			jne SkipA		    		    	//  If Not, Next Please (@f jumps to nearest Unamed Lable @@:)
		    	mov ebx, [eax]				  //  [FORWARD] Module 
		    	mov ecx, [eax+4]    		    	//  [BACKWARD] Module
		    	mov [ecx], ebx				  //  Previous Module's [FORWARD] Notation, Points to us, Replace it with, Module++
		    	mov [ebx+4], ecx			    //  Next Modules, [BACKWARD] Notation, Points to us, Replace it with, Module--
			jmp InMemoryOrderModuleList		//  Hidden, so Move onto Next Set
		SkipA:
			cmp edx, esi					    //  Reached End of Modules ?
			jne LoopInLoadOrderModuleList		//  If Not, Re Loop

InMemoryOrderModuleList:
		mov eax, dwPEB_LDR_DATA		  //  PEB->ProcessModuleInfo
		mov esi, [eax+14h]			   //  ProcessModuleInfo->InMemoryOrderModuleList[START]
		mov edx, [eax+18h]			   //  ProcessModuleInfo->InMemoryOrderModuleList[FINISH]

		LoopInMemoryOrderModuleList: 
			lodsd
			mov esi, eax
			mov ecx, [eax+10h]
			cmp ecx, hModule
			jne SkipB
				mov ebx, [eax] 
				mov ecx, [eax+4]
				mov [ecx], ebx
				mov [ebx+4], ecx
				jmp InInitializationOrderModuleList
		SkipB:
			cmp edx, esi
			jne LoopInMemoryOrderModuleList

InInitializationOrderModuleList:
		mov eax, dwPEB_LDR_DATA				    //  PEB->ProcessModuleInfo
		mov esi, [eax+1Ch]						 //  ProcessModuleInfo->InInitializationOrderModuleList[START]
		mov edx, [eax+20h]						 //  ProcessModuleInfo->InInitializationOrderModuleList[FINISH]

		LoopInInitializationOrderModuleList: 
			lodsd
			mov esi, eax		
			mov ecx, [eax+08h]
			cmp ecx, hModule		
			jne SkipC
				mov ebx, [eax] 
				mov ecx, [eax+4]
				mov [ecx], ebx
				mov [ebx+4], ecx
				jmp Finished
		SkipC:
			cmp edx, esi
			jne LoopInInitializationOrderModuleList

		Finished:
			popfd;
			popad;
	}
}

So jetzt hab ich es richitg.Es soll zwar ein hack werden aber nur für Singelplayer.

#include "resource.h"
#include "procfunc.h"

------ Erstellen gestartet: Projekt: DMA HÄXXN, Konfiguration: Debug Win32 ------
Kompilieren...
main.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2054: Nach 'Variablendeklarationen' muss '(' folgen
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2085: 'firstRun': Nicht in der formalen Parameterliste enthalten
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2143: Syntaxfehler: Es fehlt ';' vor '='
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\main.c(5) : fatal error C1083: Datei (Include) kann nicht geöffnet werden: "log.h": No such file or directory
procfunc.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\procfunc.c(76) : warning C4996: 'stricmp' wurde als veraltet deklariert
c:\programme\microsoft visual studio 8\vc\include\string.h(213): Siehe Deklaration von 'stricmp'
Meldung: "The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _stricmp. See online help for details."
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\procfunc.c(96) : warning C4996: 'stricmp' wurde als veraltet deklariert
c:\programme\microsoft visual studio 8\vc\include\string.h(213): Siehe Deklaration von 'stricmp'
Meldung: "The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _stricmp. See online help for details."
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\procfunc.c(343) : warning C4102: 'InLoadOrderModuleList': Unreferenzierte Marke
Code wird generiert...
Das Buildprotokoll wurde unter "file://c:\Dokumente und Einstellungen\keller\Desktop\Neuer Ordner\Neuer Ordner\DMA_HÄXXN___Win32_Debug\BuildLog.htm" gespeichert.
DMA HÄXXN - 4 Fehler, 3 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Zweitens: Hast du zufällig etwas mit dem User "Chenoa" zu tun? (die letzten Warnmeldungen kommen mir irgendwie bekannt vor)

Drittens: Schreibst du eigentlich C oder C++? Wenn ersteres, würde ich dich eine Etage höher verschieben.

c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2054: Nach 'Variablendeklarationen' muss '(' folgen
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2085: 'firstRun': Nicht in der formalen Parameterliste enthalten
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2143: Syntaxfehler: Es fehlt ';' vor '='

Diese Fehler müsstest du auch selbst raushauen können, schließlich steht Zeilennummer und Begründung dabei...

Erstmal: Kannst du mal dazusagen, welche der oben angegebenen Dateien welche ist (und du cheats.h dazugeben)?

Zweitens: Hast du zufällig etwas mit dem User "Chenoa" zu tun? (die letzten Warnmeldungen kommen mir irgendwie bekannt vor)

Drittens: Schreibst du eigentlich C oder C++? Wenn ersteres, würde ich dich eine Etage höher verschieben.

Ja ich kenne ihn von eine Page.Da gibts source codes.Ich schätze die hat er auch genommen

----- Erstellen gestartet: Projekt: DMA HÄXXN, Konfiguration: Debug Win32 ------
Kompilieren...
main.c
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\cheats.h(27) : error C2054: Nach 'Variablendeklarationen' muss '(' folgen
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\main.c(27) : error C2449: '{' auf Dateiebene gefunden - fehlt der Funktionskopf?
c:\dokumente und einstellungen\keller\desktop\neuer ordner\neuer ordner\main.c(261) : fatal error C1004: Unerwartetes Dateiende gefunden.
Das Buildprotokoll wurde unter "file://c:\Dokumente und Einstellungen\keller\Desktop\Neuer Ordner\Neuer Ordner\DMA_HÄXXN___Win32_Debug\BuildLog.htm" gespeichert.
DMA HÄXXN - 3 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Wenn ich bei der ersten fehler meldung ne { setze geht es immer noch nicht

.\rsrc.rc(10) : fatal error RC1015: cannot open include file 'afxres.h'.

Sry wegen meine doppelpost kann einer sie löschen?

Ich glaube du benutzt VC++ Express dan kann er es nicht.(Stimmt das?)

Helft ihm bloss net, cheater an die Wand!