Program		: Examine32 v3.11
Opis		: Wyszukiwarka textowa
Cel		: Patch
URL		: http://www.examine32.com ,albo ChipCD chyba 5/2ooo
Ograniczenia	: Nagscreeny
Tools		: SoftIce,hiew,hexworkshop,unaspack,odrobina wyobrazni ;)
ToolsURL	: http://www.crackpltools.prv.pl/

0.Rozeznanie
Chwila w hiew pokazuje, ze program jest spakowany aspackiem(v.2ooo)
nie ma mozliwosci wprowadzenia s/n,ale naszym celem bedzie zrobienie
patcha

1.Jakiekolwiek zmiany plikow dostarczonych z examine(exe-k glowny oraz
pomocnicze dll-e) powoduja,ze zostaje wyswietlony msg box z textem,ze pliki
sa uszkodzone nastepnie program sie nie uruchamia.Ok wiec jakos musi to sprawdzac,
najpewniej otwiera plik i na podstawie odczytanych z niego bajtow oblicza jakas
sume kontrolna,wiec bpx CreateFileA do "d esp->4;p ret;",i jak sie okazuje procka
sprawdzajaca znajduje sie w bibliotece Aq32_102.dll,bibioteka ta rowniez jest spakowana
aspackiem(1.0.8.x),po rozpakowaniu i deasemblacji tego pliku mozna zauwazyc ze kod
odpowiedzialny za sprawdzanie pliku siedzi w procedurze InitFile,ktora jest 
wywolywana dla sprawdzenia kolejno wszystkich plikow z examine

.text:00401724 InitFile proc near
...
.text:00401768 push    0
.text:0040176A push    0
.text:0040176C push    3
.text:0040176E push    0
.text:00401770 push    1
.text:00401772 push    80000000h
.text:00401777 lea     edx, [ebp-110h]
.text:0040177D push    edx
.text:0040177E call    j_CreateFileA		; otworz plik
.text:00401783 mov     [ebp-4], eax		; zapisz uchwyt
.text:00401786 loc_0_401786:       ; CODE XREF: InitFile+B1j
.text:00401786 push    0
.text:00401788 lea     ecx, [ebp-0Ch]
.text:0040178B push    ecx
.text:0040178C push    2000h			; ile czytac bajtow
.text:00401791 push    edi			; bufor gdzie zostana odczytane bajty
.text:00401792 push    dword ptr [ebp-4]	; uchwyt pliku
.text:00401795 call    j_ReadFile		; odczytaj z pliku
.text:0040179A test    eax, eax			; czy wystapil blad?
.text:0040179C jz      short loc_0_4017A3	; jesli tak to wyjdz z procki
...
tutaj obliczana jest suma kontrolna,nastepnie sprawdzane sa warunki

.text:004017D3 loc_0_4017D3:       ; CODE XREF: InitFile+83j InitFile+89j
.text:004017D3 test    edx, edx
.text:004017D5 jnz     short loc_0_401786
.text:004017D7 push    dword ptr [ebp-4]
.text:004017DA call    j_CloseHandle
.text:004017DF xor     bl, [ebp+8]
.text:004017E2 mov     al, [ebp+8]
.text:004017E5 xor     [ebp-5], al
.text:004017E8 test    bl, bl			; jesli bl!=0 pokaz msg box-a
.text:004017EA jnz     short loc_0_4017F8-------+
.text:004017EC cmp     byte ptr [ebp-5], 0      |
.text:004017F0 jnz     short loc_0_4017F8-------+
.text:004017F2 cmp     byte ptr [ebp-6], 0      |
.text:004017F6 jz      short loc_0_401840-------->- !wyjscie z procki bez bledu!
.text:004017F8 loc_0_4017F8: <------------------+
...
.text:0040182D push    offset aProgramError ; "Program Error"
.text:00401832 lea     eax, [ebp-214h]
.text:00401838 push    eax
.text:00401839 push    0
.text:0040183B call    j_MessageBoxA		; pokaz info
.text:00401840 loc_0_401840:
.text:00401840 push    edi
.text:00401841 call    sub_0_4092C8
.text:00401846 pop     ecx
.text:00401847 loc_0_401847:       ; CODE XREF: InitFile+2Aj
.text:00401847 xor     eax, eax
.text:00401849 mov     al, bl

po paru testach okazuje sie ze wystarczy nastepujaco zmienic dll-a
zeby sie juz nie rzucal

.004017E8: 2BDB		sub         ebx,ebx
.004017EA: 90		nop
.004017EB: 90		nop
.004017EC: C645FB00	mov         b,[ebp][-0005],000 ;" "
.004017F0: 90		nop
.004017F1: 90		nop
.004017F2: C645FA00	mov         b,[ebp][-0006],000 ;" "
.004017F6: EB48		jmps       .000401840	; !wyjscie z procki bez bledu!

ok samokontrole mamy za soba,czas wziac sie za nagscreeny

2.Ok jak mamy pod reka unaspacka,to z niego korzystamy,innym zostaje
TRW albo SICE+bhrama server,po rozpakowaniu glownego exe ladujemy go
jakiegos edytorka hex, najlepiej hex workshopa,aby pozbyc sie nagow skorzystamy
ze starej metody.Gdy zaczynalem swoja "edukacje"  przeczytalem w helpie do Oscara jak sprawic
aby programy w C,C++ nie wyswietlaly nagscreenow,caly trick polegal na tym aby w pliku
EXE danego programu znalezc tekst(najczesciej w postaci UNICODE)z okienka owego
nagscreena,np.w HexWorkshopie uzywajac opcji UNICODE.Gdy
znajdziemy juz interesujacy nas text nalezy w jego poblizu poszukac sekwencji
bajtow FF FF FF FF 82 lub rzadziej FF FF 82 gdy cos takiego znajdziemy te 82 zmieniamy
na 90 lub 7E zapisujemy tak zmieniony plik i jezeli bedziemy mieli szczescie nag juz sie
nie pojawi!
a) 1 nagscreen
Po wystartowaniu programu pojawia sie nam na ok 5s okienko z textem
UNREGISTERED VERSION a wiec otwieramy progsa(juz rozpakowanego) w hex workshopie
CTRL-F i wpisujemy ten text z naga

00033990 82 00 45 00 78 00 61 00 6D 00 69 00 6E 00 65 00 ..E.x.a.m.i.n.e.
000339A0 33 00 32 00 20 00 76 00 33 00 2E 00 31 00 31 00 3.2. .v.3...1.1.
000339B0 00 00 00 00 01 00 02 50 00 00 00 00 0D 00 2A 00 .......P......*.
000339C0 84 00 08 00 FF FF FF FF*82*00 43 00 6F 00 70 00 ..........C.o.p. <--magiczny bajt
000339D0 79 00 72 00 69 00 67 00 68 00 74 00 20 00 A9 00 y.r.i.g.h.t. ...
000339E0 20 00 41 00 71 00 75 00 69 00 6C 00 61 00 20 00  .A.q.u.i.l.a. .
000339F0 53 00 6F 00 66 00 74 00 77 00 61 00 72 00 65 00 S.o.f.t.w.a.r.e.
00033A00 2C 00 20 00 31 00 39 00 39 00 33 00 2D 00 32 00 ,. .1.9.9.3.-.2.
00033A10 30 00 30 00 30 00 00 00 00 00 00 00 03 00 00 50 0.0.0..........P
00033A20 00 00 00 00 1E 00 0B 00 15 00 14 00 FF FF FF FF ................
00033A30 82 00 FF FF 01 00 00 00 01 00 02 50 00 00 00 00 ...........P....
00033A40 24 00 35 00 55 00 08 00 FF FF FF FF 82 00 41 00 $.5.U.........A.
00033A50 6C 00 6C 00 20 00 72 00 69 00 67 00 68 00 74 00 l.l. .r.i.g.h.t.
00033A60 73 00 20 00 72 00 65 00 73 00 65 00 72 00 76 00 s. .r.e.s.e.r.v.
00033A70 65 00 64 00 00 00 00 00 01 00 02 50 00 00 00 00 e.d........P....
00033A80 19 00 46 00 6B 00 08 00 FF FF FF FF 82 00 2A 00 ..F.k.........*.
00033A90 2A 00 20 00 55 00 4E 00 52 00 45 00 47 00 49 00 *. .U.N.R.E.G.I. <--text z nagscreena
00033AA0 53 00 54 00 45 00 52 00 45 00 44 00 20 00 56 00 S.T.E.R.E.D. .V.
00033AB0 45 00 52 00 53 00 49 00 4F 00 4E 00 20 00 2A 00 E.R.S.I.O.N. .*.

Czasami w pobilzu textu z nag-a jest wiecej sekwencji FFFFFFFF82 trzeba
po prostu poekperymentowac az sie uda :),w moim przypadku ten magiczny
bajt znalazl sie pod offsetem 339C8h,teraz wystarczy zamienic 82h na 90h
Uruchamiamy program ponownie,nie ma startowego nag-a ale za to gdy
wychodzimy z programu pojawia sie nam jeszcze jeden :(
b) 2 nagscreen
Postepujemy dokaldnie tak jak w podpunkcie a tyle tylko,ze teraz szukamy
textu z 2 naga np. Registration Reminder

00033590 00 00 52 00 65 00 67 00 69 00 73 00 74 00 72 00 ..R.e.g.i.s.t.r. <--text z belki
000335A0 61 00 74 00 69 00 6F 00 6E 00 20 00 52 00 65 00 a.t.i.o.n. .R.e.    tytulowej
000335B0 6D 00 69 00 6E 00 64 00 65 00 72 00 00 00 08 00 m.i.n.d.e.r.....
000335C0 48 00 65 00 6C 00 76 00 00 00 00 00 01 00 03 50 H.e.l.v........P
000335D0 00 00 00 00 58 00 A9 00 37 00 0E 00 03 00 FF FF ....X...7.......
000335E0 80 00 4F 00 72 00 64 00 65 00 72 00 20 00 26 00 ..O.r.d.e.r. .&.
000335F0 46 00 6F 00 72 00 6D 00 00 00 00 00 00 00 03 50 F.o.r.m........P
00033600 00 00 00 00 1F 00 A9 00 20 00 0E 00 01 00 FF FF ........ .......
00033610 80 00 26 00 4F 00 4B 00 00 00 00 00 01 00 02 50 ..&.O.K........P
00033620 00 00 00 00 40 00 15 00 4C 00 08 00 FF FF FF FF ....@...L.......
00033630*82*00 45 00 78 00 61 00 6D 00 69 00 6E 00 65 00 ..E.x.a.m.i.n.e. <--magiczny bajt

znowu 82 zamieniamy na 90h
Ok program mamy juz zlamany heh ale tylko na wlasny uzytek,jesli chcelibysmy zrobic
tradycyjnego patch-a to nie ma szans!Program(oryginalny) jest przeciez spakowany
a wiec jak do cholery mozna zmusic go u kogos innego do pracy jako full?
Sa 2 a wlasciwie 3 rozwiazania
1.Kupic licencje(niektorzy sie zaczna smiac)
2.Kopac w kompa tak dlugo az sie uruchomi ;)
3.Poszukac crackow ew. s/n or keyfile na astalaviscie

ale mozna jeszcze inaczej...

3.Patchowanie spakowanego programu

a)patchowanie exe-ka
Ok wiemy, ze program jest spakowany aspackiem,wykonywanie spakowanego programu
moze przedstawic taki banalny schemat

   
oryginalny_entrypoint:
		spakowany_kod db ...
		
kod_aspacka:
		call	rozpakuj_spakowany_kod
		jmp	oryginalny_entrypoint


Po skompresowaniu exeka aspackiem entrypoint jest ustawiany tak, ze wskazuje
na kod depakera,po uruchomieniu nastepuje rozpakowanie sekcji,nastepnie zostaje wykonany
skok do oryginalnego entrypointu programu.Wiec juz jedno wiemy napewno,zanim
nastapi skok do oryginalnego entrypointu dane sa juz rozpakowane,wiec jak spatchowac
takie badziestwo?Ano najprosciej jest tak:


oryginalny_entrypoint:
		spakowany_kod db ...
		
kod_aspacka:
		call	rozpakuj_spakowany_kod
		call	procka_patchujaca_VA	; <--nasz kod
		jmp	oryginalny_entrypoint

Heh ale gdzie jest w kodzie aspacka znajduje sie skok do oryginalnego entrypointu?
Poniewaz prog jest spakowany aspackiem mamy szczescie poniewaz autor aspacka nie umiescil
kodu odpowiedzialnego za powrot do entrypointu w jakims "schowku" jest podany
prawie jak na tacy(?):

.0043E4F1: 61		popad			; przywroc stan rejestrow
.0043E4F2: 7508		jne        .00043E4FC	; przeskocz
.0043E4F4: B801000000	mov         eax,1	; wykonanie tego kodu spowodowaloby zakonczenie
.0043E4F9: C20C00	retn        0000C	; wykonaywania programu(nieudokumentowny sposob na exit process)
.0043E4FC: 6800000000	push        000000000	; tutaj zamiast push 0 bedzie zapisane np push 401000 tzn adres entrypointu
.0043E501: C3		retn			; skok do oryginalnego entrypointu

Przypuszczalnie kod spod adresu .0043E4F4 jest wykonywany wowczas gdy wystapil
jakis blad podczas depakowania kodu,na szczescie aspack jest na tyle stabilnym
pakerem ze nie mialem szczescia zobaczyc zeby ten kod byl kiedykolwiek wykonywany
,a wiec pytanie jak mozna wykorzystac ta luke dla naszych celow?Instrukcje
jne+mov eax,1+ ret 0Ch zajmuja lacznie 10 bajtow czyli calkiem sporo :)),mozna tam
wcisnac jakiegos call-a do procki patchujacej

	mov	eax,offset lpVAProckiPatchujacej
	call	eax		; wywolaj procke patchujaca
	popad			; przywroc stan rejestrow
	db	3 dup(90h)	; nop padding
	push	00000000
	retn
lacznie 10 bajtow.Ok teraz czas na to jak wygladalaby procka patchujaca

lpVAProckiPatchujacej:
	call	_delta
_delta:	pop	ebp
	sub	ebp,offset _delta

	mov	ecx,_tablen	; liczba patchow
	lea	esi,[ebp+_table]; esi wsakzuje na tabele z offsetami patchow(VirtualAddress)
_apply_patch:
	lodsd			; zaladuj VA kolejnego patch-a
	xchg	eax,edi		; do edi
	lodsb			; bajt ktory wstawiamy
	stosb			; zapisz bajt pod zadany VA
	loop	_apply_patch	; powtorz

	ret			; powroc

; table_entry struc
; patch_offset	dd ?
; patch_byte	db ?
; ends

_table:
	dd	offset VAPierwszegoPatcha
	db	90h

	dd	...
	db	...

_tablen	equ ($-_table)/5	; DWORD+BYTE
_patchlen	equ $-_patch

Ok mam nadzieje ze teraz bedziecie umieli juz sobie skleic swoja procke
patchujaca.Teraz pozostaje kwestia gdzie zapisac ta procke.Najczesciej exe pakery
dopisuja sobie dodatkowa sekcje(z wlasnych doswiadczen wiem ze latwiej jest dopisac
dodatkowa sekcje do exeka w przypadku pakerow)rozmiar fizyczny sekcji jest
zaokraglany do wartosci file align zapisanej w naglowku PE.Co to znaczy?
Ano to, ze jezeli taki paker doda sobie swoja sekcje do exeka i jej rozmiar
nie jest podzielny bez reszty przez wartosc file align to dopisane zostaja dodatkowe
bajty tak aby romiar fizyczny byl podzielny przez file align bez reszty.Te
dodatkowe bajty to przewaznie nieuzytkowna przestrzen w pliku,niestety te zaokraglenia
musza byc ze wzgledu na kompatybilnosc z innymi systemami operacyjnymi(NT hi Dulek ;)
W przypadku examine nie zostalo zbyt wiele wolnej przestrzeni do wykorzystnia
na koncu pliku(nie chce mi sie pisac jak rozszerzyc ostatnia sekcje sorry :()
ale predko odnajdujemy taka wolna przestrzen miedzy przedostatnia sekcja a sekcja
aspacka VA==0043D630h(1CE30 offset w pliku spakowanym)

A wiec przygotowujemy sobie najpierw kod ktory bedzie zapisany przed kodem aspacka
gdzie jest skok do entrypointu

@1:
	mov	eax,43D630h	; VA procki patchujacej
	call	eax		; wywolaj procke patchujaca
	popad			; przywroc stan rejestrow
	db	3 dup(90h)	; nop padding
	push	00000000
	ret
@1l	equ	$-@1

Ten fragment musimy zapisac tutaj:
.0043E4F1: 61	popad			; przywroc stan rejestrow

VA 43E4F1h == 1D4F1h offset w pliku

Teraz chyba najwazniejsze,mianowicie przygotowanie tabeli z wirtualnymi
adresam patchow.Zeby prog funkcjonowal bez nagow i bez info o virusie w exeku
nalezy spatchowac 2 pliki exe i dll najpierw zajmiemy sie patchowaniem exeka.
W exeku nalezalo wyeliminowac nagi,patche w pliku znajdowaly sie pod offsetami

339C8h = 4381C8h VA  1 nag
33630h = 437E30h VA  2 nag

offsety te nalezy zamienic na VA nastepnie te VA zapisac w tabeli

@2:
;	int 3			; dla testow

	call	_delta
_delta:	pop	ebp
	sub	ebp,offset _delta

	mov	ecx,_tablen	; liczba patchow
	lea	esi,[ebp+_table]; esi wsakzuje na tabele z offsetami patchow(VirtualAddress)
_apply_patch:
	lodsd			; zaladuj VA kolejnego patch-a
	xchg	eax,edi		; do edi
	lodsb			; bajt ktory wstawiamy
	stosb			; zapisz bajt pod zadany VA
	loop	_apply_patch	; powtorz

	ret			; powroc

; table_entry struc
; patch_offset	dd ?
; patch_byte	db ?
; ends

_table:
	dd	4381C8h
	db	90h		; 82h >> 90h

	dd	477E30h
	db	90h		; 82h >> 90h

_tablen	equ ($-_table)/5	; DWORD+BYTE
_patchlen	equ $-_patch
@2l	equ	$-@2

tak spreparowana procke zapisujemy pod adres 1CE30 w spakowanym exeku.
Ok exek uruchamia sie spoko,ale tylko jesli mamy spatchowna "fizycznie" biblioteka
Aq32_102.dll jesli umiescimy w katalogu oryginalna znowu pokaze sie nam info ze
plik exe jest uszkodzony :(.Biblioteka Aq32_102.dll jest rowniez spakowana aspackiem
,zeby aspack mogl zapisac rozpakowany kod do jakiejs sekcji musi mies ona ustawione
atrybuty write.Zapytacie i co z tego?Mozna to bardzo sprytnie wykorzystac :))

	push	offset lpAQ32_102
	call	LoadLibraryA albo GetModuleHandleA

	push	offset lpInitInitFile
	push	eax
	call	GetProcAddress

	mov	byte ptr[eax+przesuniecie],patch

korzystajac z funkcji api zadeklarowanych w tabeli importow aspacka
(korzysta m.in z GetProcAddress,GetModuleHandleA,LoadLibraryA) umiescimy kod
patchujacy dll-a w procedurze patchowania exe-ka,tym sposobem upieczemy 2 pieczenie
na jendym ogniu ;)

Pierwsza sprawa jakie sa offsety funkcji api w tabeli importow aspacka?Latwo sie
tego dowiedziec sledzac kod aspacka zaraz po uruchomieniu exeka

.0043E062: 83BD0448440000	cmp         d,[ebp][000444804],000 ;" "
.0043E069: 899D04484400		mov         [ebp][000444804],ebx
.0043E06F: 0F8566040000		jne        .00043E4DB   -------- (1)
.0043E075: 8D850C484400		lea         eax,[ebp][00044480C]
.0043E07B: 50			push        eax
.0043E07C: FF9518494400		call        d,[ebp][000444918]	; <--GetModuleHandle
.0043E082: 898508484400		mov         [ebp][000444808],eax
.0043E088: 8BF8			mov         edi,eax
.0043E08A: 8D9D19484400		lea         ebx,[ebp][000444819]
.0043E090: 53			push        ebx
.0043E091: 50			push        eax
.0043E092: FF9514494400		call        d,[ebp][000444914]	; <--GetProcAddress

gdy bedziemy pod .0043E07C piszemy w sice ?ebp+44480C i mamy VA gdzie zapisany
jest offset procki GetModuleHandle jesli wpiszemy ?ebp+44480C+4 otrzymamy
VA gdzie jest adres LoadLibraryA,podobnie pod .0043E092 ?ebp+444914 i mamy
offset GetProcAddres.Korzystamy z LoadLibraryA poniewaz GetModuleHandle nie zawsze
dziala.

Ok mamy funkcje api potrzebne do spatchowania dll-a
ale jakie beda offsety?To proste po wywolaniu GetProcAddress w eax bedzie adres
procki ktorej bajty musimy spatchowac,czyli eax to taki adres bazowy,zeby
otrzymac offset gdzie zapiszemy patch nalezy:

.text:00401724 InitFile proc near		; w eax dostaniemy adres tej procki(VA)
...
.text:004017E8 test    bl, bl			; tutaj musi byc uaktualniony patch
.text:004017EA jnz     short loc_0_4017F8
.text:004017EC cmp     byte ptr [ebp-5], 0
.text:004017F0 jnz     short loc_0_4017F8

004017E8h-00401724h=0C4h przesuniecie wzgledem poczatku funkcji InitFile

Kompletna procka patchujaca

@2:
	call	_delta
_delta:	pop	ebp
	sub	ebp,offset _delta

	mov	ecx,_tablen	; liczba patchow
	lea	esi,[ebp+_table]; esi wsakzuje na tabele z offsetami patchow(VirtualAddress)
_apply_patch:
	lodsd			; zaladuj VA kolejnego patch-a
	xchg	eax,edi		; do edi
	lodsb			; bajt ktory wstawiamy
	stosb			; zapisz bajt pod zadany VA
	loop	_apply_patch	; powtorz

	lea	eax,[ebp+ag_102]
	push	eax
	mov	eax,43EF78h	; adres [LoadLibraryA]
	call	dword ptr[eax]	; adres gdzie biblioteka jest zaladowana(module base)

	lea	edx,[ebp+InitFile]
	push	edx
	push	eax
	mov	eax,43EF70h	; adres [GetProcAddress]
	call	dword ptr[eax]	; pobierz adres funkcji

	lea	edi,[eax+0C4h]	; edi offset patcha
	lea	esi,[ebp+patch_data]
	db	6Ah		; push byte
	db	patch_len	; rozmiar
	pop	ecx
	rep	movsb		; uaktualnij patcha

	ret			; powroc
aq_102		db	'AQ32_102.DLL',0
InitFile	db	'InitFile',0

patch_data	db	2Bh,0DBh	; sub	ebx,ebx
		db	90h,90h		; 2xnop
		db	0C6h,45h,0FBh,0	; mov	byte ptr[ebp-5],0
		db	90h,90h		; 2xnop
		db	0C6h,45h,0FAh,0	; mov	byte ptr[ebp-6],0
		db	0EBh,48h	; jmp
patch_len	equ	$-patch_data


; table_entry struc
; patch_offset	dd ?
; patch_byte	db ?
; ends

_table:
	dd	4381C8h
	db	90h		; 82h >> 90h

	dd	477E30h
	db	90h		; 82h >> 90h

_tablen	equ ($-_table)/5	; DWORD+BYTE
_patchlen	equ $-_patch
@2l	equ	$-@2


Uwaga!
Patchowanie ma tylko sens gdy bibioteka jest dolaczana statycznie do exeka,
tzn ze windows zanim uruchomi exeka wykona LoadLibraryA i wypelni tabele
importow adresami funkcji z tejze biblioteki.Gdyby program korzystal
z wlasnych procedur obslugi tej biblioteki to raczej nie ma sensu pisac
procki patchujacej(teoretycznie LoadLibraryA laduje biblioteke ale
jezeli byla ona wczesniej zaladowana zwraca tylko module base,cala
mapa pamieci gdzie jest zaladowana biblioteka jest nietknieta!!)
,chociaz mozna wykorzystac luki.Luki te mozliwe ,ze beda poprawione
w nastepnych ver systemu operacyjnego wiec nigdy nie wiadomo
jak bedzie w innym systemie wygladalo LoadLibraryA bo calkiem
mozliwe ,ze bedzie to FreeLibrary i potem LoadLibraryA co znaczy
ze wszystkie zmiany jakich dokonalismy pojda sie walic,dlaczego?
Poniewaz zostanie zaladowana "czysta" biblioteka.(taki refresh)

Nie ma sensu takze patchowac miejsc w bibliotece gdzie sa wykonywane
operacje na offsetach np.

401000	mov	eax,401000h
401005	mov	ecx,edx

zalozmy ze image base tej biblioteki wynosi 400000h gdy biblioteka ta
jest ladowana do pamieci w przestrzen adresowa,moze sie zdarzyc ze
obszar od 400000h-x bedzie zajety przez jakas inna biblioteka.Jesli
zdarzy sie taka sytuacja, system zobaczy ze np obszar od 500000h(?)
jest wolny wtedy zostana zaktualizowane wszystkie instrukcje ktore potrzebuja
updatu zeby dzialac poprawnie,czyli np instrukcje ktore wskazywaly jakies offsety
i wtedy nasze

401000	mov	eax,401000h
401005	mov	ecx,edx
zostanie zastapione np.
501000	mov	eax,501000h
501005	mov	ecx,edx

my cos spatchujemy "na sucho" a system to spatchuje runtime i wszystko do...
Mozna natomiast do woli patchowac instrukcje ktore nie korzystaja
z offsetow bo te nigdy nie sa uaktualniane(no bo niby co mialoby byc
uaktualnione?Nazwy rejestrow ;)

System korzysta z tzw tabeli relokacji(przewaznie sekcja .reloc) aby
uaktualnic potrzebne dane,warto w tym miejscu dodac ze pliki wykonywalne
pe exe podczas kompilacji takze zostaja wyposazone w tabele relokacji
tyle tylko, ze pliki pe exe zawsze sa ladowane pod zadany adres bazowy,
wiec sekcja reloc jest bezuzyteczna w przypadku exekow.


4.Slowo koncowe
Ten tut mial pokazac jak mozna "inaczej" patchowac,nie mial na celu
opsisu jak zlamac examine,wiec jesli sa jeszcze jakies "niespodzianki"
to mam nadzieje ,ze juz sobie poradzicie sami :)

PS.
Wszelkie uwagi,sugestie,pytania,bluzgi mile widziane

bart
cryogen@free.net.pl

