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?
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?
OpenProcess möchte von dirhaben. Also für dwDesiredAccess z.B welche Zugriffsrechte du auf diesen Prozess haben möchtest.Code:HANDLE WINAPI OpenProcess( __in DWORD dwDesiredAccess, __in BOOL bInheritHandle, __in DWORD dwProcessId );
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.
Geändert von EBFE (16.07.2009 um 10:09 Uhr)
TrueCrypt/RAR/Zip Passwort vergessen und das Bruten dauert ewig? Oder brauchst du fein abgestimmte Wortlisten? Hilf dir selbst mit WLML - Word List Markup Language
Gib Stoned/Mebroot/Sinowal und anderen Bootkits keine Chance: Anti Bootkit v 0.8.5
Dies gibt mir nun ein Access Violation zurück. Aber sonst müsste alles richtig sein oder?Code:#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); }
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:
Ausgabe (PID ist in dem fall von meinem Explorer)Code:#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; }
Code: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
Geändert von EBFE (16.07.2009 um 12:51 Uhr)
TrueCrypt/RAR/Zip Passwort vergessen und das Bruten dauert ewig? Oder brauchst du fein abgestimmte Wortlisten? Hilf dir selbst mit WLML - Word List Markup Language
Gib Stoned/Mebroot/Sinowal und anderen Bootkits keine Chance: Anti Bootkit v 0.8.5
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 ...
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?
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).
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.Zitat von SleiZer
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:
ausgabe (bei mir zumindest):Code:#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; }
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).Code: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
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
Geändert von EBFE (16.07.2009 um 16:51 Uhr)
TrueCrypt/RAR/Zip Passwort vergessen und das Bruten dauert ewig? Oder brauchst du fein abgestimmte Wortlisten? Hilf dir selbst mit WLML - Word List Markup Language
Gib Stoned/Mebroot/Sinowal und anderen Bootkits keine Chance: Anti Bootkit v 0.8.5
Also mein Programm sieht jetzt so aus:
nun kriege ich aber Trotz abfrage von zwei verschiedenen Prozessen das selbe Ergebnis ... Wie kann das sein?Code:#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; }
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 ...
Geändert von SleiZer (29.07.2009 um 01:19 Uhr) Grund: Automerged Doublepost