[PROBLEM] Funktion Byte für Byte kopieren (im Arbeitsspeicher)

Hallo,
also ich bin nach ner Auszeit jetzt wieder dabei mich am API-Hooking zu versuchen,mit
komplett neuem Code!
Zu aller erst wollte ich mal eine Funktion im Arbeitsspeicher kopieren,in ein Noparray welches ich dann im Gepatchten Programm aufrufe,wie eine Funktion!
Gut,dachte ich mir da liest du einfach die eine Funktion Byteweise aus und
schreibst jedes Byte einzeln in die Platzhaltenfunktion...Denkste!
Also hier erst mal das zu manipulierende Programm:

tests.cpp

#include <windows.h>
#include <iostream>
using namespace std;

int klaut(void);
int klauen(void);

int main(void)
{
klaut();
cout << "Klauen:" << (void*)&klauen << endl << "Klaut:" << (void*)&klaut << endl;
system("pause");
return 1;
}

int klauen(void)
{
cout << "KLAPPT!\n";
}

int klaut(void)
{
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
}

Kommentare für (Fehler)Infos lesen

manipulieren.cpp

#include <windows.h>
#include <iostream>
#include <string>
using namespace std;

void copy_function(unsigned ,unsigned ,unsigned );
unsigned get_retn(unsigned ); //gibt die Adresse zurück an der das erste mal ab
                              //der Übergebenen Adresse 0xC3(RETN-Opcode) im Code vorkommt

HANDLE hproc;
DWORD rw = 0;
STARTUPINFO si;
PROCESS_INFORMATION pi;
char buffer = 0xC3;
unsigned temp_addr = 0x401436; //Adresse von "klauen"
unsigned char test = 0x0;

int main(void)
{

    if(CreateProcess("tests.exe",0,0,0,0,CREATE_SUSPENDED,0,0,&si,&pi)) //Das Programm zum patchen öffnen
    {
     hproc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pi.dwProcessId); //Rechte zum patchen holen
     copy_function(temp_addr,get_retn(temp_addr),0x401452/*Adresse von klaut*/);
//Den Code von "klauen" bis zum RETURN kopieren,und zwar nach "klaut"
     system("PAUSE");
     ResumeThread(pi.hThread);
    }

    CloseHandle(hproc);
    return 0;
} 

void copy_function(unsigned source_adress,unsigned end,unsigned target_adress)
{
  end++;
  unsigned old = target_adress;
  unsigned char byte = 0x0;
  cout << hex << source_adress << " " << end << " " << target_adress << endl;
  while(source_adress != end)/*Solange lesen bis ich alles zwischen 
source_adress und end nach target_adress kopiert hab*/
  {
   ReadProcessMemory(hproc,(LPCVOID)source_adress++,&byte,sizeof(byte),&rw);
   cout << hex <<(int)byte  << endl; 
   WriteProcessMemory(hproc,(LPVOID)target_adress++,&byte,sizeof(byte),&rw);
  }  
  cout << "--\n";
//Hier könnt ihr nochmal Debugcode sehen,und der beweist es wird ALLES Kopiert
//Am Output hab ich nämlich mittels OllyDBG rausgefunden das ALLES aus klauen kopiert zu sein scheint
//Der Code liest den Speicher von "klaut" aus den ich eben beschreiben habe
  do
  {
   ReadProcessMemory(hproc,(LPCVOID)old++,&byte,sizeof(byte),&rw);
   cout << hex <<(int)byte  << endl;
  }while(byte != 0xC3);
}

unsigned get_retn(unsigned addr)
{
  unsigned char byte = 0x0;

  do
  {
   ReadProcessMemory(hproc,(LPCVOID)addr++,&byte,sizeof(byte),&rw);
  }while(byte != 0xC3);

  return --addr;
}

So mein eigentliches Problem ist jetzt das tests.exe immer abstürzt wenn ich
patchen lasse(kommt immer der eine Fehler,da wo gefragt wird ob ich den Bericht
an M$ senden will )
Die Rückgabe von allen Funktionen hab ich gecheckt (nochmal sorry @ Jochen wegen
letztem Mal ),es muss also am Prinzip meines Codes liegen!

Wär echt Froh wenn mir jemand helfen könnte
Xalon

0x401452 ist nicht die richtige Addresse von klaut() sondern nur zum Eintrag in er ILT. Der Code ist so unübersichtlich, klaut() klauen() etc. Gib doch mal vernünftige Bezeichner an. Und wieso versuchst du es nicht zuerst im eigenen Prozeß?

Doch die Adresse stimmt ich habs mit OllyDBG geprüft:

00401452  /$  55                      PUSH EBP
00401453  |.  89E5                    MOV EBP,ESP
00401455  |.  90                      NOP
00401456  |.  90                      NOP
[...]
00401471  |.  90                      NOP
00401472  |.  90                      NOP
00401473  |.  5D                      POP EBP
00401474  \.  C3                      RETN

Und warum soll ichs denn im eigenen Prozess versuchen wenn ich es gleich im
fremden Prozess machen kann?Das spart mir nacher Arbeit und ist auch nicht weiter schwierig.
Und was ist schwer daran klaut von klauen zu unterscheiden?
Ja ich weiß hätte besser gewählt werden können aber man kann ihn doch trotzdem
noch schön lesen,oder?

Schon mal Danke für jede hilfe,
Xalon

Ok ich weiß jetzt an was es liegt,und zwar daran das JMP xxxxx != JMP xxxxx da als Opcode nicht das Ziel eines Jumps angegeben wird sondern die Entfernung
was dazu führt das der selbe Jump an einer anderen Adresse ins Nirvana geht

Xalon

So,sorry das ich so viele Doppelposts mache aber diesmal gehts nicht um mich,ich will nur eben meinen Source zeigen,vielleicht kann ihn ja jemand zum anschauen brauchen

#include <windows.h>
#include <iostream>
#include <string>
using namespace std;

void instead_call(int );
void source_function(int );
void new_adress(void);
unsigned sprungoffset(unsigned ,unsigned );
void hook_function(unsigned ,unsigned ,unsigned ,unsigned ,DWORD );

typedef void (*MyFuncType)(int );

unsigned char test = 0x0;

int main(void)
{

     hook_function((unsigned)&source_function,6,(unsigned)&new_adress,(unsigned)&instead_call,GetCurrentProcessId());
     source_function(1);
     system("PAUSE");
     return 0;
} 
/*
unsigned source_function = zu hookende Funktion
unsigned bytes_to_save   = Bytes die gespeichert werden,vorher mit einem Debugger anschauen um keine Opcodes zu zerreisen
unsigned new_adress      = Wenn mann diese Adresse aufruft kommt man zur ungehookten Funktion
unsigned instead_call    = Diese Funktion wird aufgerufen statt der alten,von hier kann man die alte aufrufen
DWORD process_id         = Gibt an in welchem Prozess die Hooks gemacht werden
*/
void hook_function(unsigned source_function,unsigned bytes_to_save,unsigned new_adress,unsigned instead_call,DWORD process_id)
{
  unsigned char byte;
  DWORD rw = 0;
  HANDLE hproc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process_id);
  unsigned temp_adress[10];
  temp_adress[0] = source_function;
  temp_adress[1] = new_adress;
  /* Liest x Bytes von source_function ein,überschreibt sie mit NOPs und sichert sie zu new_adress */  
 for(int i = 0;i < bytes_to_save;i++)
  {
   ReadProcessMemory(hproc,(LPCVOID)source_function,&byte,sizeof(byte),&rw);
   WriteProcessMemory(hproc,(LPVOID)new_adress++,&byte,sizeof(byte),&rw);
   byte = 0x90;
   WriteProcessMemory(hproc,(LPVOID)source_function++,&byte,sizeof(byte),&rw);   
  }  
  /* Schreibt in die vorher geschaffenen NOPs einen JMP zu instead_call */
  temp_adress[2] = source_function;
  source_function = temp_adress[0];
  byte = 0xE9;
  WriteProcessMemory(hproc,(LPVOID)source_function,&byte,sizeof(byte),&rw);
  temp_adress[3] = sprungoffset(source_function,instead_call);
  WriteProcessMemory(hproc,(LPVOID)++source_function,&temp_adress[3],sizeof(temp_adress[3]),&rw);  
  /* Schreibt nach den vorher gesicherten Bytes einen JMP zur Originalfunktion zurück */  
  byte = 0xE9;
  new_adress = temp_adress[1];
  new_adress += bytes_to_save;
  WriteProcessMemory(hproc,(LPVOID)new_adress++,&byte,sizeof(byte),&rw);   
  temp_adress[4] = sprungoffset(temp_adress[1]+bytes_to_save,temp_adress[0]+5);
  WriteProcessMemory(hproc,(LPVOID)new_adress,&temp_adress[4],sizeof(temp_adress[4]),&rw);

  CloseHandle(hproc);
}

void source_function(int i)
{
cout << i << "\n";
}

void instead_call(int i)
{
cout << i << "N!" << i << "\n";
MyFuncType fp;
fp = (MyFuncType)(unsigned)&new_adress;
fp(9999);
}

unsigned sprungoffset(unsigned absprung,unsigned ziel)
{
  unsigned weg;
  absprung += 5;
  weg = ziel - absprung;
  return weg;
}

void new_adress(void)
{
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
asm("NOP");
}

Neku

Was hast du eigentlich vor?
Einen Call zu einer Funktion durch einen Call auf deine eigene Funktion zu ersetzen? Das mache ich im Moment täglich, aber im eigenen Prozess, da ich das per DLL mache.

Ich hab vor damit ne Art Sniffer zu schreiben

Neku

Xalon_ schrieb:

Ich hab vor damit ne Art Sniffer zu schreiben

Bitte etwas genauer, was du machen möchtest

net 0

ihr solltet es mal damit versuchen: http://research.microsoft.com/sn/detours/
das nimmt euch ne menge arbeit ab...