Programm im Speicher ermitteln

Bitpatcher · Beitrag von **Bitpatcher** » 20.02.2008 20:18

Hallo.

Wie kann ich ermitteln, wo sich ein per RunProgram() gestartetes Programm im Speicher befindet (also Anfang und Ende)?

Kann ja auch gerne mit APIs gelöst werden...

Gruß,
Bitpatcher

Fluid Byte · Beitrag von **Fluid Byte** » 20.02.2008 21:41

Um was zu tun?

Bitpatcher · Beitrag von **Bitpatcher** » 20.02.2008 22:14

Um DisASMCommand & GetDisASMString darauf anwenden zu können.

Bitpatcher · Beitrag von **Bitpatcher** » 20.02.2008 22:26

Hm, hab gerade eine andere Idee... ungefähr so müßte es doch auch gehen, oder?

OpenFile()
AllocateMemory()
ReadData()
CloseFile()

Dann kann ich doch DisASMCommand & GetDisASMString auf den Speicherbreich anwenden, nicht?

(Soll ein Mini-Disassembler werden)

Bitpatcher

Fluid Byte · Beitrag von **Fluid Byte** » 20.02.2008 22:26

Das funktioniert nur mit PB Programmen. Falls das ne Art Debugger werden soll nimm lieber gleich OllyDBG.

[edit]
Nein, das sind nur die binären Daten auf der Festplatte, nicht der Anwendungsspeicher.

Bitpatcher · Beitrag von **Bitpatcher** » 20.02.2008 22:42

Nein, das sind nur die binären Daten auf der Festplatte, nicht der Anwendungsspeicher.

Deshalb ja: AllocateMemory() und ReadData()

Das funktioniert nur mit PB Programmen.

Ich glaube, da liegst Du nicht ganz richtig.

Die PB-Hilfe sagt:

ASMBefehl$ = GetDisASMString()

Ermittelt den ASM-Befehl von der im Aufruf von DisASMCommand() angegebenen Adresse.

Ergebnis = DisASMCommand(Speicheradresse)

Ermittelt die Adresse der nächsten ASM-Anweisung im Speicher, mit der Suche wird bei der angegebenen Adresse begonnen.

Im Speicher befindet sich Opcode, kein PB-Code. Inwiefern der Windowsloader die physikalischen Daten beim Laden ins RAM verändert, weiß ich leider nicht so genau. Ich glaube aber, daß sie NAHEZU gleich sind. Da glauben aber bekanntlich nicht wissen ist, wäre es wohl wirklich sinnvoller, den Windowsloader seine Arbeit machen zu lassen und dann das fertig geladene Programm aus dem RAM zu lesen -> siehe Eingangspost bzgl. RunProgram().

Gruß,
Bitpatcher

P.S.

Der OllyDbg ist ein SUPER Werkzeug, nutze es bereits seit längerer Zeit.[/quote]

Kaeru Gaman · Beitrag von **Kaeru Gaman** » 20.02.2008 22:53

du bekommst probleme mit den zugriffsrechten.
ein prozess darf nicht einfach auf den speicher eines anderen zugreifen,
schon garnicht auf die code-segmente.

Bitpatcher · Beitrag von **Bitpatcher** » 20.02.2008 22:58

Echt? Mist!

Ich dachte, daß zumindest ein Lesezugriff immer erlaubt ist...

Dann bliebe noch meine zweite Idee, welche für meine Zwecke auch ausreichend wäre. Ginge das?

Bitpatcher

edel · Beitrag von **edel** » 21.02.2008 04:23

Du kannst beide Wege gehen. Und beide Wege duerften sich
auch mit Hilfe der Error-Lib auslesen lassen.

Olly:

Code: Alles auswählen

00401000 >/$ 68 0C000000    PUSH 0C                                ; /n = C (12.)
00401005  |. 68 00000000    PUSH 0                                 ; |c = 00
0040100A  |. 68 C8324000    PUSH 123456.004032C8                   ; |s = 123456.004032C8
0040100F  |. E8 EC0F0000    CALL <JMP.&CRTDLL.memset>              ; \memset
00401014  |. 83C4 0C        ADD ESP,0C
00401017  |. 68 00000000    PUSH 0                                 ; /pModule = NULL
0040101C  |. E8 E50F0000    CALL <JMP.&KERNEL32.GetModuleHandleA>  ; \GetModuleHandleA
00401021  |. A3 CC324000    MOV DWORD PTR DS:[4032CC],EAX
00401026  |. 68 00000000    PUSH 0                                 ; /MaximumSize = 0
0040102B  |. 68 00100000    PUSH 1000                              ; |InitialSize = 1000 (4096.)
00401030  |. 68 00000000    PUSH 0                                 ; |Flags = 0
00401035  |. E8 D20F0000    CALL <JMP.&KERNEL32.HeapCreate>        ; \HeapCreate
0040103A  |. A3 C8324000    MOV DWORD PTR DS:[4032C8],EAX
0040103F  |. E8 DC110000    CALL 123456.00402220
00401044  |. E8 6F110000    CALL 123456.004021B8
00401049  |. E8 D20F0000    CALL 123456.00402020
0040104E  |. 68 0C304000    PUSH 123456.0040300C
00401053  |. 68 0C304000    PUSH 123456.0040300C
00401058  |. E8 04100000    CALL 123456.00402061
0040105D  |. 68 00000000    PUSH 0
00401062  |. E8 10000000    CALL 123456.00401077
00401067  |. FF35 C8324000  PUSH DWORD PTR DS:[4032C8]             ; |/hHeap = NULL
0040106D  |. E8 A00F0000    CALL <JMP.&KERNEL32.HeapDestroy>       ; |\HeapDestroy
00401072  \. E8 A10F0000    CALL <JMP.&KERNEL32.ExitProcess>       ; \ExitProcess
00401077  /$ E8 50110000    CALL 123456.004021CC
0040107C  \. C3             RETN

Beispiel:

Code: Alles auswählen

401000 - PUSH 0000000C
401005 - PUSH 00000000
40100A - PUSH 004032C8
40100F - CALL 003817C8
401014 - ADD Esp,0C
401017 - PUSH 00000000
40101C - CALL 003817CE
401021 - MOV [004032CC],Eax
401026 - PUSH 00000000
40102B - PUSH 00001000
401030 - PUSH 00000000
401035 - CALL 003817D4
40103A - MOV [004032C8],Eax
40103F - CALL 003819E8
401044 - CALL 00381980
401049 - CALL 003817E8
40104E - PUSH 0040300C
401053 - PUSH 0040300C
401058 - CALL 00381829
40105D - PUSH 00000000
401062 - CALL 0038083F
401067 - PUSH dword [004032C8]
40106D - CALL 003817DA
401072 - CALL 003817E0
401077 - CALL 00381994
40107C - RET

Code: Alles auswählen

Procedure GetBaseAddress(FileName.s,pid.l)
	Protected hsnap
	Protected found
	Protected Module.MODULEENTRY32
	Protected ModuleBase

	hsnap = CreateToolhelp32Snapshot_(#TH32CS_SNAPMODULE, pid )

	Module\dwSize = SizeOf(MODULEENTRY32)
	Found = Module32First_( hsnap, Module )

	While Found
	
		Module\dwSize = SizeOf(MODULEENTRY32)		
		If LCase(PeekS(@Module\szModule)) = LCase(FileName.s)
			ModuleBase = Module\modBaseAddr + 4096
			Break
		EndIf 
		
		Found = Module32Next_(hsnap,Module)	
	Wend 
		
	CloseHandle_(hsnap)
	ProcedureReturn ModuleBase
EndProcedure

#prg	= "123456.exe"
rByte	= 0
prg	= RunProgram(#prg,"","",#PB_Program_Open)

Delay(400)

If prg
	pid	=	ProgramID(prg)
	base	=	GetBaseAddress(#prg,ProgramID(prg))
	*buf	=	AllocateMemory(5000)
	hProc	=	OpenProcess_(#PROCESS_ALL_ACCESS, 0, pid)
		
	If hProc	
		ReadProcessMemory_(hProc,base,*buf,150,@rByte)

		ende  = *buf + 150
		
		While *buf < ende
			pos  = *buf
			*buf = DisASMCommand(*buf)
			Debug Hex(base) + " - " + GetDisASMString()	
			base + (*buf - pos)
		Wend 

	EndIf 
		
EndIf

Wie du siehst ist das von KG angesprochene Problem nicht wirklich ein
Problem. Allerdings kenne ich mich damit nicht wirklich aus, als das ich
dir etwas besseres liefern koennte.

Und im Anfaenger Forum hat das ganze ueberhaupt nichts zu suchen

Bitpatcher · Beitrag von **Bitpatcher** » 21.02.2008 20:15

Vielen Dank für Deine Hilfe und die Mühe, die Du Dir gemacht hast.

Hab gestern die halbe Nacht rumprobiert und hab dann meinen Code (ähnlich wie Deiner) für Mist befunden, hab ihn gelöscht und bin ins Bett geplumpst, wo ich den Rest der Nacht wach lag und über mein Problem grübelte. ES FUNKTIONIERT BEI MIR NICHT!!! Leider auch nicht Dein Code...

Schau mal, das liefert Dein Code:

OllyDbg

Code: Alles auswählen

00402000 >/$  6A 00         PUSH 0                                   ; /Style = MB_OK|MB_APPLMODAL
00402002  |.  68 00104000   PUSH test.00401000                       ; |Title = "Bitpatcher"
00402007  |.  68 1A104000   PUSH test.0040101A                       ; |Text = "Irgend ein Text..."
0040200C  |.  6A 00         PUSH 0                                   ; |hOwner = NULL
0040200E  |.  FF15 3C304000 CALL DWORD PTR DS:[<&USER32.MessageBoxA>>; \MessageBoxA
00402014  |.  803D 71104000>CMP BYTE PTR DS:[401071],1
0040201B      74 14         JE SHORT test.00402031
0040201D  |.  6A 00         PUSH 0                                   ; /Style = MB_OK|MB_APPLMODAL
0040201F  |.  68 3A104000   PUSH test.0040103A                       ; |Title = "INFO"
00402024  |.  68 51104000   PUSH test.00401051                       ; |Text = "Bla, bla, bla..."
00402029  |.  6A 00         PUSH 0                                   ; |hOwner = NULL
0040202B  |.  FF15 3C304000 CALL DWORD PTR DS:[<&USER32.MessageBoxA>>; \MessageBoxA
00402031  \>  C3            RETN

Purebasic

Code: Alles auswählen

401000 - INC Edx
401001 - IMUL Esi,65686374
401009 - JB 00CD1E9B
40100B - ADD [eax],al
40100D - ADD [eax],al
40100F - ADD [eax],al
401011 - ADD [eax],al
401013 - ADD [eax],al
401015 - ADD [eax],al
401017 - ADD [eax],al
401019 - ADD [ecx+72],cl
40101C - db 67h
GS: OUTSB 
40101F - FS: AND FS:[ebp+69],ah
401023 - OUTSB 
401024 - AND [ebp+78],dl
401028 - JZ 00CD1EE8
40102A - CS: CS: ADD CS:[eax],al
40102E - ADD [eax],al
401030 - ADD [eax],al
401032 - ADD [eax],al
401034 - ADD [eax],al
401036 - ADD [eax],al
401038 - ADD [eax],al
40103A - DEC Ecx
40103B - DEC Esi
40103C - INC Esi
40103D - DEC Edi
40103E - ADD [eax],al
401040 - ADD [eax],al
401042 - ADD [eax],al
401044 - ADD [eax],al
401046 - ADD [eax],al
401048 - ADD [eax],al
40104A - ADD [eax],al
40104C - ADD [eax],al
40104E - ADD [eax],al
401050 - ADD [edx+6C],al
401053 - POPAD 
401054 - SUB al,20
401056 - BOUND Ebp,[ecx+2C]
40105A - AND [edx+6C],ah
40105D - POPAD 
40105E - CS: CS: CS: ADD CS:[eax],al
401063 - ADD [eax],al
401065 - ADD [eax],al
401067 - ADD [eax],al
401069 - ADD [eax],al
40106B - ADD [eax],al
40106D - ADD [eax],al
40106F - ADD [eax],al
401071 - ADD [eax],al
401073 - ADD [eax],al
401075 - ADD [eax],al
401077 - ADD [eax],al
401079 - ADD [eax],al
40107B - ADD [eax],al
40107D - ADD [eax],al
40107F - ADD [eax],al
401081 - ADD [eax],al
401083 - ADD [eax],al
401085 - ADD [eax],al
401087 - ADD [eax],al
401089 - ADD [eax],al
40108B - ADD [eax],al
40108D - ADD [eax],al
40108F - ADD [eax],al
401091 - ADD [eax],al
401093 - ADD [eax],al
401095 - ADD [eax],al

Das ist irgendwie nicht das gleiche.

Woran kann das liegen?

HIER kann man meine Test.exe runterladen.

Gruß,
Bitpatcher