Access Violation unterdrücken

[SleiZer]

Irgendwie fehlt mir da gerade was.
Wenn openprocess und readprocessmemory funktionen sind,
dann muss ich denen ja die Werte geben und bekomme sie nicht von zurück was ich doch eingentlich wollte, oder verstehe ich da etwas falsch?

[EBFE]

OpenProcess möchte von dir

HANDLE WINAPI OpenProcess(
  __in  DWORD dwDesiredAccess,
  __in  BOOL bInheritHandle,
  __in  DWORD dwProcessId
);

haben. Also für dwDesiredAccess z.B welche Zugriffsrechte du auf diesen Prozess haben möchtest.
Zum lesen des Speichers wären das PROCESS_VM_READ (==0x0010) und PROCESS_QUERY_INFORMATION (==0x0400). Beides sind Konstanten, die in windows.h oder ähnlichem definiert werden sollten (falls nicht, trägt man manuell eben die Werte ein).
Das mit dem Handle ist erstmal uninteressant. ProzessID wäre die Identifikationsnummer des Prozess. Wird z.B im Taskmanager angezeigt (muss man eventuell in der Ansicht -> PID Spalte aktivieren). Du bekommst die PID auch, wenn du wie im letzen Posting erwähnt, die Prozessliste durchgehst.
Wenn du z.B nach der PID von explorer.exe suchst, dann gehst du die Liste durch, bekommst eine PROCESSENTRY32 Struktur zurück und vergleichst den szExeFile String mit dem gewünschen (in dem fall "explorer.exe").
Du kannst natürlich auch erstmal die PID selber nachschauen und deinem Programm als Parameter übergeben.

ReadProccess möchte halt den Handle zum Prozess haben (den man mit OpenProcess bekommt), die gewünschte Adresse, ab der du den Speicher auslesen möchtest, wieviele Bytes du lesen willst und natürlich einen Buffer, in den überhaupt eingelesen werden kann (du kopierst damit den "fremden" Speicherbreich in deinen eigenen). Der letze Paramter ist die Adresse der Variablen, in die dann geschrieben wird, wieviele Bytes gelesen wurden. Hier kann man auch 0 übergeben.

[SleiZer]

#include <windows.h>
#include <stdio.h>
#define PROCESS_ID_MANUAL 4888

void main()
{
    void *puffer;
    void *pressid;
    void *startip;
    unsigned int *bytes;

    pressid= OpenProcess(PROCESS_VM_READ,1,PROCESS_ID_MANUAL);
    ReadProcessMemory(pressid,startip,puffer,100,bytes);
    
    printf("%s", (char)*puffer); 
}

Dies gibt mir nun ein Access Violation zurück. Aber sonst müsste alles richtig sein oder?

[EBFE]

Damit sind wir schon mal weiter
Allerdings: puffer musst du schon mal selbst initialisieren. Deine startip ist auch nicht initialisiert. Um die Funktion zu testen, setze sie erstmal auf 0x400000 oder 0x1000000 (die üblichen Imagebasen der Exen - da sollte sich immer was zum auslesen finden). Außerdem solltest du entweder den Compiler nennen ("einfacher C Compiler" ist keine Bezeichnung ) oder halt auf GCC (MingW32) für Windows umsteigen. Mein GCC wirft bei deinem Code schon ziemlich viele Warnungen

Btw: mit printf %s den Speicherdump auszugeben ist keine gute Idee - es wird nur bis zur ersten 00 ein "string" ausgegeben.

Das ist dein Code etwas angepasst, getestet mit gcc:

#include <windows.h>
#include <stdio.h>
#define PROCESS_ID_MANUAL 1168

int main()
{
    unsigned char puffer[256];
    void *pressid;
    void *startip;
    unsigned int bytes;

    pressid= OpenProcess(PROCESS_VM_READ,1,PROCESS_ID_MANUAL);
    ReadProcessMemory(pressid,(void*)0x400000,puffer,100,&bytes);
    
    printf("%s", puffer); /* gibt nur MZ aus, weil danach 00 kommen */
    /*bisschen aufgeppept*/
    printf("konnte 0x%X Bytes einlesen\n",bytes);
    int i;
    for (i=1;i<bytes-1;i++)
    {
       printf("%0.2X ",puffer[i-1]);
       if ((i%16==0)) printf("\n"); /*Zeilenumbruch alle 16 Bytes*/
    }
    return 0;
}

Ausgabe (PID ist in dem fall von meinem Explorer)

MZÉkonnte 0x64 Bytes einlesen
4D 5A 90 00 03 00 00 00 04 00 00 00 FF FF 00 00
B8 00 00 00 00 00 00 00 40 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 E8 00 00 00
0E 1F BA 0E 00 B4 09 CD 21 B8 01 4C CD 21 54 68
69 73 20 70 72 6F 67 72 61 6D 20 63 61 6E 6E 6F
74 20

[Keksdose]

cool läuft (Dev-C++) Mir stellen sich da 2 Fragen:
1. Warum stürzt das irgend wann ab? also wie bei einer Endlosschleife "has stopped working"
2. Was fang ich denn damit an? Kann ich auch meinen eigenen Code da reinschmuggeln oder so?

PS: kenn mich in C++ aus aber net mit Speicher ...

[SleiZer]

Also jeder Prozess kriegt einen Speicher von 4gb zugewiesen.
Das heißt man müsste von der Addresse 0 bis zur Addresse 4gb,
auslesen um den ganzen Prozess zusehen?

Wenn ich jetzt von der Addresse 0 start hört er aber nicht mehr auf zulaufen.
Er läuft bis zu einem Access Violation.

Kann man vor dem Access Violation auch anhalten oder muss ich den Access Violation unterdrücken, damit das Programm nicht abstürtzt?

[EBFE]

1. Warum stürzt das irgend wann ab? also wie bei einer Endlosschleife "has stopped working"
2. Was fang ich denn damit an? Kann ich auch meinen eigenen Code da reinschmuggeln oder so?

1)keine Kristallkugel anwesend . Ist nur rudimentärer Beispielcode, ohne Fehlerprüfungen.
2)Threadstarter wollte speicher anderer Programme auslesen. Und anfangen kann man damit schon einiges. Unter anderem auch eigenen Code/Daten schreiben (Stichwort:Codeinjection, memory patching).

Wenn ich jetzt von der Addresse 0 start hört er aber nicht mehr auf zulaufen.
Er läuft bis zu einem Access Violation.

Kann man vor dem Access Violation auch anhalten oder muss ich den Access Violation unterdrücken, damit das Programm nicht abstürtzt?

Du kannst nicht ALLES auslesen. Wie schon gesagt, es werden nicht die geamten 4 GB belegt. Viele Bereiche sind erstmal frei und werden erst auf eine Anforderung des Programms zugewiesen (z.B über VirtualAlloc bzw über C-Runtime DLL mit malloc - kommt allerdings auf die konkrete C-Runtime Bibliothek an)[1]. Vor dem Auslesen solltest du also erstmal mit VirtualQueryEx prüfen, wie groß der Bereich ist und welche Flags er hat.

Wenn der Speicher eine MEM_FREE Markierung besitzt, hat es keinen Sinn, diesen auszulesen . Dann geht man zum nächsten Speicherblock.

Btw: Ne AccessViolation kommt in dem Fall sowieso nicht vom auslesen (da liefert ReadProcessMemory eine 0 zurück), sondern weil ich im Beispielcode die
"bytes" als unsigned deklariert hab. Wenn 0 Bytes eingelesen wurde, stand in der FOR-schleife praktisch for(i=0;i<0xFFFFFFFE;i++). Das ist der Nachteil, wenn man mal schnell eine hübsche Ausgabe basteln will. Mit einem Debugger allerdings sehr schnell zu finden - und mit dem sollte man sich sowieso anfreunden, wenn man sich mit Low-Level Sachen (Speicherauslesen, Manipulieren usw) beschäfitgen möchte

korrektes Beispiel:

#include <windows.h>
#include <stdio.h>
#define PROCESS_ID_MANUAL 1168

int dump(void* hProcess,void *base,int size)
{
  unsigned char* buff= malloc(size);
  int bytes=0;
  
  int result=ReadProcessMemory(hProcess,base,buff,size,&bytes);
  if (result!=0)  
          printf("konnte 0x%X Bytes einlesen von 0x%0.8X\n",bytes,base);
  else 
  {
     printf("konnte 0x%0.8X NICHT auslesen\n",base);
     free(buff);
     return 0;
  }
  
    int i;
    for (i=1;i<bytes-1 && i<size-1;i++)
    {
       printf("%0.2X ",buff[i-1]);
       if ((i%16==0)) printf("\n"); /*Zeilenumbruch alle 16 Bytes*/
    }
    free(buff);
    return 0;
}
int main()
{ 
    unsigned char puffer[256];
    void *pressid;
    void *startip;
    pressid= OpenProcess(PROCESS_VM_READ,1,PROCESS_ID_MANUAL);
    dump(pressid,(void*)0x1000,50);
    dump(pressid,(void*)0x400000,50);
    dump (pressid,(void*)0x600000,50);
    dump (pressid,(void*)0x80000000,50); /*sollte nix ausgeben,
    da OS reserviert*/
    return 0;
}

ausgabe (bei mir zumindest):

konnte 0x00001000 NICHT auslesen
konnte 0x32 Bytes einlesen von 0x00400000
4D 5A 90 00 03 00 00 00 04 00 00 00 FF FF 00 00
B8 00 00 00 00 00 00 00 40 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
konnte 0x32 Bytes einlesen von 0x00600000
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
konnte 0x80000000 NICHT auslesen

Schöner wäre es allerdings wie erwähnt, mit VirtualQueryEx erstmal abzufragen, was Sache ist. Denn die meisten kleineren Programme belegen nur paar MB des RAMs. Man braucht also nicht stur alle 4GB durchzuklappern und zu dumpen (was dann auch recht langsam wäre).

PS/OT: GCC -Wall wird ein paar Warnungen ausspucken weil bei den APIs ich recht gnadenlos caste. Allerdings hatte ich keine Lust in den Defs/Headern zu wühlen und richtige typedefs zu suchen - das sollte schließlich nur ein Beispiel sein . Außerdem kann ich C nicht wirklich - erinnert mich zu sehr an C++, um sich damit rumzuplagen

[SleiZer]

Also mein Programm sieht jetzt so aus:

#include <windows.h>
#include <stdio.h>
#include<fcntl.h>
#define PROCESS_ID_MANUAL 1484

int main()
{
    unsigned char puffer[1024];
    void *pressid;
    void *startip;
    unsigned int bytes=1024;
    char puffer2[2] ="H";
    int stream_r;
    char test[] = "c:/text.txt";
    stream_r=open(test,O_WRONLY);    
    pressid= OpenProcess(PROCESS_VM_READ,1,PROCESS_ID_MANUAL);
    ReadProcessMemory(pressid,(void*)0x0,puffer,100,&bytes);
    
    printf("%s", puffer); /* gibt nur MZ aus, weil danach 00 kommen */
    /*bisschen aufgeppept*/
    printf("konnte 0x%X Bytes einlesen\n",bytes);
    int i;
    for (i=1;i<bytes-1;i++)
    {
       printf("%0.2X ",puffer[i-1]);
      // if(isprint(puffer[i-1]) || puffer[i-1] == 20)
        if(puffer[i-1] != 0)
        {
        write(stream_r,&puffer[i-1],1);
        }  
       if ((i%16==0)) printf("\n"); /*Zeilenumbruch alle 16 Bytes*/
    }
    system("pause");
    return 0;
}

nun kriege ich aber Trotz abfrage von zwei verschiedenen Prozessen das selbe Ergebnis ... Wie kann das sein?

Ich glaube das weicht gerade vom Topic ab...
ich habe das Thema im Thread neugestartet
http://free-hack.com/showthread.php?p=360212#post360212
ansonsten kann dieser thread geschlossen werden ...