CreateRemoteThread mit mehreren parameter

B

Biohazard90

0
Hallo an alle,
ich wollte mal fragen wie es möglich ist eine Funktion mit mehreren Parametern mithilfe von CreateRemoteThread aufzurufen?

also z.b.

void Test(int a,int b){
printf("%i %i\n",a,b);
return;
}

und diese will ich nun aufrufen. Die Funktion kann ich nicht verändern. Hab mir gedacht vielleicht eine struct zumachen die in die memory zuschreiben und die dann zu übergeben aber das klappt nicht.

Bitte um Hilfe. Code Beispiele wären nett (wenns geht c++ aber kann auch ne andere sprache sein) ;)

Vielen Dank für eure Hilfe!
 
Warum soll das nicht klappen?

Definiere dir eine finalisierte Struktur (keine offenen Arrays!) und schreibe sie in den Speicher. Übergebe anschließen einen Pointer zu dieser Struktur dem CreateRemoteThread
 
Ok vielleicht habe ich auch was falsch gemacht ich poste mal meinen Code:

Ausführender Code:

Code: 
#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <shlwapi.h>

#define CREATE_THREAD_ACCESS (PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ)


bool SetDebugPrivileges()
{
	HANDLE hToken;
	TOKEN_PRIVILEGES tokenPriv;
	tokenPriv.PrivilegeCount = 1;

	if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
		return false;

	if(!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tokenPriv.Privileges[0].Luid))
		return false;
	tokenPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

	if(!AdjustTokenPrivileges(hToken, false, &tokenPriv, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
		return false;
	return true;
}

unsigned long GetTargetProcessIdFromProcname(char *procName)
{
   PROCESSENTRY32 pe;
   HANDLE thSnapshot;
   BOOL retval, ProcFound = false;

   thSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

   if(thSnapshot == INVALID_HANDLE_VALUE)
   {
      MessageBox(NULL, "Error: unable to create toolhelp snapshot", "Loader", MB_OK);
      return false;
   }

   pe.dwSize = sizeof(PROCESSENTRY32);

   retval = Process32First(thSnapshot, &pe);

   while(retval)
   {
      if(StrStrI(pe.szExeFile, procName) )
      {
         ProcFound = true;
         break;
      }

      retval    = Process32Next(thSnapshot,&pe);
      pe.dwSize = sizeof(PROCESSENTRY32);
   }

   return pe.th32ProcessID;
}

struct asi{
  int a;
  int b;     
};

int main() {
    asi ab;
    ab.a = 10;
    ab.b = 20;
    LPVOID param;
    
    //burn.exe func-adress = 0x00401290
   //hab ich mit olly geholt
    SetDebugPrivileges();
    
    DWORD procid = GetTargetProcessIdFromProcname("burn.exe");
    if(procid == 0x00000000){
             printf("Error: Process not found!");
             getchar();
             return 0;
    }
    
    HANDLE Proc = OpenProcess(CREATE_THREAD_ACCESS,FALSE,procid);
    
    param=VirtualAllocEx(Proc, NULL, sizeof(asi), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
    WriteProcessMemory(Proc, param, (LPVOID)&ab, sizeof(asi), NULL);
    
    CreateRemoteThread(Proc, NULL, 0, (LPTHREAD_START_ROUTINE)0x00401290, param, 0, NULL);
    
    CloseHandle(Proc);
    
    getchar();
    return 0;   
}

Opfer-Programm(burn.exe):

Code: 
#include <stdio.h>

void Burn(int a,int b){
     printf("%i %i\n",a,b);
     return;    
}

int main(){
    Burn(1,2);
    getchar();
    return 0;   
}

Achja ansich funktioniert das, also die funktion wird aufgerufen nur zeigt sie extrem komische und wirre Werte an.
 
Dann klappt es, nur das Problem ist, dass ich das so haben möchte das es auch mit void Burn(int a,int b) funktioniert, weil ich dann Funktionen aus einem Programm aufrufen möchte das ich nicht geschrieben habe und somit die Funktionen auch nicht ändern kann ohne Quellcode.
 
Du kannst aber CreateRemoteThread nicht zwingen, mehrere Parameter zu übergeben ;)

Dann musst Du es entweder über eine "Zwischenfunktion" schalten:
void myBurn(int* p[]){
Burn(p[0],p[1]);
return;
}
Zum Vergrößern anklicken....

oder die Parameter "manuell" reinschreiben. Die erste Version lässt sich zumindet ohne Assembly erledigen. Sowas für die Zwischenfunktion sollte gehen:
Code: 
void zw_Burn(int *p[])
{
   void (*func) (int a,int b);
   func=(void*)0x00401290;   <--- Adresse der Funktion aus Deinem geposteten Code
   func(p[0],p[1]);
}

Du musst eben nicht nur die Parameter, sondern auch diesen Code kopieren und statt "burn" die Zwischenfunktion aufrufen
 
Super CDW danke das geht super!

EDIT: Falls es wen interressiert wie ich das gemacht habe:

Prozess der Funktion aus einem anderen Prozess aufruft
Code: 
#include <windows.h>
#include <stdio.h>
#include <tlhelp32.h>
#include <shlwapi.h>

#define CREATE_THREAD_ACCESS (PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ)

bool SetDebugPrivileges()
{
	HANDLE hToken;
	TOKEN_PRIVILEGES tokenPriv;
	tokenPriv.PrivilegeCount = 1;

	if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
		return false;

	if(!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tokenPriv.Privileges[0].Luid))
		return false;
	tokenPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

	if(!AdjustTokenPrivileges(hToken, false, &tokenPriv, sizeof(TOKEN_PRIVILEGES), NULL, NULL))
		return false;
	return true;
}

unsigned long GetTargetProcessIdFromProcname(char *procName)
{
   PROCESSENTRY32 pe;
   HANDLE thSnapshot;
   BOOL retval, ProcFound = false;

   thSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

   if(thSnapshot == INVALID_HANDLE_VALUE)
   {
      MessageBox(NULL, "Error: unable to create toolhelp snapshot", "Loader", MB_OK);
      return false;
   }

   pe.dwSize = sizeof(PROCESSENTRY32);

   retval = Process32First(thSnapshot, &pe);

   while(retval)
   {
      if(StrStrI(pe.szExeFile, procName) )
      {
         ProcFound = true;
         break;
      }

      retval    = Process32Next(thSnapshot,&pe);
      pe.dwSize = sizeof(PROCESSENTRY32);
   }

   return pe.th32ProcessID;
}

typedef void (*burn)(int,int);

struct Parameter{
  burn pFunc;
  int a;
  int b;     
};

static void burnFunc(Parameter *p)
{  
   p->pFunc(p->a,p->b);
}
void endFunc(void) { }

int main() {
    Parameter p;
    p.a = 10;
    p.b = 20;
    //Adresse der Funktion void burn(int,int) in burn.exe
    p.pFunc = (burn)0x00401290;

    LPVOID param,func;
    HANDLE hThread;
    
    //Debug Privilegien holen
    SetDebugPrivileges();
    
    DWORD procid = GetTargetProcessIdFromProcname("burn.exe");
    if(procid == 0x00000000){
             printf("Error: Process not found!");
             getchar();
             return 0;
    }
    
    //Prozess öffnen
    HANDLE Proc = OpenProcess(CREATE_THREAD_ACCESS,FALSE,procid);
    
    //Speicher für Parameter Struktur reservieren
    param=VirtualAllocEx(Proc, NULL, sizeof(Parameter), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
    //Speicher für Funktion reservieren
    func=VirtualAllocEx(Proc, NULL, (DWORD)((DWORD)endFunc-(DWORD)burnFunc), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    
    //Parameter schreiben
    WriteProcessMemory(Proc, param, (LPVOID)&p, sizeof(Parameter), NULL);
    
    //Funktion reinschreiben
    WriteProcessMemory(Proc, func, (LPVOID)burnFunc, (DWORD)((DWORD)endFunc-(DWORD)burnFunc), NULL);
    
    //Funktion aufrufen
    hThread = CreateRemoteThread(Proc, NULL, 0, (LPTHREAD_START_ROUTINE)func, param, 0, NULL);

   //Warten bis Thread fertig
    WaitForSingleObject(hThread,INFINITE);
        
    //Funktion aus dem Speicher entfernen
    VirtualFreeEx(Proc,(LPVOID)func,0,MEM_RELEASE);
    
    //Parameter entfernen
    VirtualFreeEx(Proc,(LPVOID)param,0,MEM_RELEASE);
    
    //Handle schließen
    CloseHandle(Proc);
    
    getchar();
    return 0;   
}

burn.exe also Prozess mit der aufzurufenden Funktion
Code: 
#include <stdio.h>

void Burn(int a,int b){
     printf("%i %i\n",a,b);
     return;    
}

int main(){
    Burn(1,2);
    getchar();
    return 0;   
}
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben