 X Ŀ B
 O ͻ P
 R  .    .Ŀ .    *    Ŀ Ŀ   . Ŀ  .    *Ŀ   .     * X
ٺ               .۳                     Ŀ
ͼ   * Ŀ    .    ۳ .    Ŀ۳    .  ڿ۳.     .  ͻ
 . Ŀ ۳  Ŀ     Ŀ.. Ŀ ۳ Ŀ Ŀ.
  ۳۳  ۳* .۳*  ۳ ۳*   ۳. ۳ 
 ٳ ۳Ŀ ڿ   Ŀ  ۳  
*. ٳ ۳۳. Ŀ ۳  ڿ..  
 ۳   . ۳  ۳۳ٳ۳   ۳۳ ۳    
        ۳ ٳ۳ .   ڿ   
 Ŀ*       .  .    *  ۳ *      Ŀ     *  ۳* 
. ۳   .                 ۳       . ۳  .     ۳ 
              .              .              ..
members:       *    .       *  members: .            *     .       members:
 *    beanus   dulek      jaro   massh    mig-21 oxcart  zetx
arakus .  coxoc   hannibal  lobix * mauzer    neo  ._r00t_  
ٺ
ͻ   .        .           *     .         .           *   ĿĿĿĿ ͼ
Ŀ official URL: http://beanus.provider.pl/     .         ٳ۳۳۳ 
 E  *     on IRC: #crackpl or #cookiecrk  *          .       C
 X ͼ M
 P  P


Cel: cp_imcm1.exe - by ImagiNativE
Nazedzia: SoftIce, disassembler, hex edytor...

Notka: cp_imcm1.exe b.dobre crackme - pomysl i wykonanie KEWL

[Ogledziny]
Po pierwszym uruchomieniu (przy obecnosci SI), a raczej nie uruchomieniu crakme wnioskujemy ze 
ma zabezpieczeni(a)e ANTY-SI. Odpalamy Wdasma i oglodamy kod. Zauwazamy ze nasz cel zawiera 
kilka metod wykrycia SI (sterowniki, exepction, idt...), znalazla sie nawet metoda anty Wdasm 
debugger. 

[Sekcja]
Wiec co by nie patrzec na dead-listing programu odpalamy go pod loaderem SI : 
Loader32.exe ->> File/Open Module ->> cp_imcm1.exe ->> Module/Load ->> ... Wiec zaczynamy
sledzic kod crackme.

* Reference To: KERNEL32.GetCurrentProcess, Ord:00E3h <--- funkcja ta zwraca tymczasowy
                                  |			   uchwyt procesu (naszego crackme)
:00401053 E8BE050000              Call 00401616
:00401058 A318324000              mov dword ptr [00403218], eax <--- przeslij uchwyt
:0040105D 6A00                    push 00000000
:0040105F 6A08                    push 00000008 <--- ilosc bajtow do zapisania
:00401061 68AD304000              push 004030AD <--- co zapisac

* Possible StringData Ref from Code Obj ->"PRZX3"
                                  |
:00401066 6803104000              push 00401003 <--- gdzie zapisac 
:0040106B FF3518324000            push dword ptr [00403218] <--- uchwyt programu 

* Reference To: KERNEL32.WriteProcessMemory, Ord:02C3h
                                  |
:00401071 E8B8050000              Call 0040162E
:00401076 EB8B                    jmp 00401003 <--- skok do zmodyfikowanego miejsca

Pod adresem xxx:00401003 kryje sie (przed zmiana) :

	      
	     | <----------------------------------------- to tu zapisujemy 8 bajtow o wartosciach	
:00401002 0550525A58              add eax, 585A5250	  kolejno :B443CD68663D86F3
:00401007 33C0                    xor eax, eax
:00401009 85C0                    test eax, eax
:0040100B 7444                    je 00401051 <--- jezeli zostanie wyk. to omija nas cala "zabawa"
:0040100D E871030000              call 00401383 <--- istotny call, o nim ponizej
:00401012 A308324000              mov dword ptr [00403208], eax 
:00401017 EB05                    jmp 0040101E			


Po zmianie wyglada te miejsce nastepujaco :
	
	[...]
	B443 	 mov ah,43 <--- w al jest 01
	CD68	 int 68
	663D86F3 cmp ax,F386
	[...]

Wiec co my tu widzimy ?:) Anty SI. Wiec gdy SI jest obecny w systemie przerwanie 68 (ax==4301)
zwroci nam F386 i zostanie wykonany skok (bez SI po int 68 => ax==4301), a tego niechcemy gdyz 
ominie nas bardzo istotna rzecz (o ktorej za chwile). Wiec piszemy r ax==4301 i przechodzimy
przez skok. Ok mamy tu jakiegos call`a xxx:0040100D wiec wchodzimy do niego i co my tu mamy.


:00401383 85C0                    test eax, eax
:00401385 7575                    jne 004013FC <--- ten skok musi zaistniec ;)
:00401387 EB0A                    jmp 00401393 <--- skacz do procki szukajacej WINICE.BRK
:00401389 57                      push edi	w pamieci, kolejna to IDT...
:0040138A 49                      dec ecx
:0040138B 4E                      dec esi
:0040138C 49                      dec ecx
:0040138D 43                      inc ebx
:0040138E 45                      inc ebp
:0040138F 2E                      BYTE 02eh


:00401390 42                      inc edx
:00401391 52                      push edx
:00401392 4B                      dec ebx

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401387(U)
|
:00401393 8D3589134000            lea esi, dword ptr [00401389] <--- tu zaczyna sie procka
:00401399 8A06                    mov al, byte ptr [esi]	 ktora przeszukuje obszar	   
:0040139B B900001000              mov ecx, 00100000		 pamieci pod kontem obecnosci	   	
:004013A0 8BD6                    mov edx, esi			 pliku WINICE.BRK - huh SI rules!
:004013A2 BF00000100              mov edi, 00010000

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004013BB(U)
|
:004013A7 FC                      cld
:004013A8 F2                      repnz
:004013A9 AE                      scasb
:004013AA 7511                    jne 004013BD <--- a tu... dojdziemy do IDT Check :)
:004013AC 4F                      dec edi
:004013AD 51                      push ecx
:004013AE B90A000000              mov ecx, 0000000A
:004013B3 F3                      repz
:004013B4 A6                      cmpsb
:004013B5 67E335                  jcxz 004013ED <--- a tu sie zapetla ta procka do pewnego momentu 
:004013B8 8BF2                    mov esi, edx
:004013BA 59                      pop ecx
:004013BB EBEA                    jmp 004013A7

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004013AA(C)
|
:004013BD F9                      stc
:004013BE 0F010D00324000          sidt [00403200]
:004013C5 A102324000              mov eax, dword ptr [00403202]
:004013CA 83C008                  add eax, 00000008
:004013CD 8B18                    mov ebx, dword ptr [eax]
:004013CF 83C010                  add eax, 00000010
:004013D2 8B00                    mov eax, dword ptr [eax]
:004013D4 25FFFF0000              and eax, 0000FFFF
:004013D9 81E3FFFF0000            and ebx, 0000FFFF
:004013DF 2BC3                    sub eax, ebx
:004013E1 83F81E                  cmp eax, 0000001E
:004013E4 7407                    je 004013ED	<--- powyzej IDT Check, a tu maly skoczek,
:004013E6 BE02144000              mov esi, 00401402  ktorego narazie nie ruszamy	
:004013EB EB06                    jmp 004013F3

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004013E4(C)
|
:004013ED 8B3504324000            mov esi, dword ptr [00403204] <--- --------------
										   |
* Referenced by a (U)nconditional or (C)onditional Jump at Address:		   |
|:004013EB(U)									   |
|										   |	
:004013F3 55                      push ebp					   |	
:004013F4 8BEC                    mov ebp, esp					   |	
:004013F6 FFD6                    call esi <--- czy to nie jest ze soba powiazane?;]
:004013F8 8BE5                    mov esp, ebp
:004013FA 5D                      pop ebp
:004013FB C3                      ret



* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401385(C)
|
:004013FC B8E6134000              mov eax, 004013E6 <--- zapamietac...
:00401401 C3                      ret

To co widzimy powyzej to calkiem fajna kombinacja ANTY-SI wiec co by tu zrobic? Huh musimy 
zadbac w eax po wejsciu do call`a byla liczba rozna od 0, mozemy to uzyskac przez modyfikacje
wczesniej zapisywanych bajtow pod adres 401003,wtedy unikniemy przedzierania sie przez 
WINICE.BRK i IDT Check - narazie (nie patchujmy tego skoku). Aby pozbyc sie klopotow zwiazanych
z szukaniem WINICE.BRK w pamieci (przyda nam to sie pozniej),  odpalamy hex edytor i szukamy 
ciagu WINICE.BRK znajdujemy go i zmieniamy np. na WINICZ.BRK - problem z WINICE.BRK mam 
z glowy, zostal nam IDT ale do niego wroce pozniej.

:00401012 A308324000              mov dword ptr [00403208], eax 
:00401017 EB05                    jmp 0040101E	

Ok wiec wsykoczylismy z procki a eax==004013E6, a pod tym adresem kryje sie mov esi, 00401402
Wiec po wyjsciu z tej procki przenosimy zawratosc eax do komorki pamieci o adresie 00403208


:0040101E 6A00                    push 00000000
:00401020 6A05                    push 00000005
:00401022 681C324000              push 0040321C <-- gdzie wczytac 
:00401027 6819104000              push 00401019 <-- co odczytaj ? :00401019 BEC0144000  mov esi, 004014C0
:0040102C FF3518324000            push dword ptr [00403218]

* Reference To: KERNEL32.ReadProcessMemory, Ord:0201h
                                  |
:00401032 E8EB050000              Call 00401622
:00401037 6A00                    push 00000000
:00401039 6A05                    push 00000005
:0040103B 681C324000              push 0040321C <--  BEC0144000 == mov esi, 004014C0
:00401040 FF3508324000            push dword ptr [00403208] <--- (eax) zapisz to co jest pod 0040321C 
:00401046 FF3518324000            push dword ptr [00403218]

* Reference To: KERNEL32.WriteProcessMemory, Ord:02C3h
                                  |
:0040104C E8DD050000              Call 0040162E

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040100B(C)
|
:00401051 EB25                    jmp 00401078 <--- tu wylondowalismy, gdyby skok z pod adresu
						:0040100B zaistanial, to spowodowaloby ominiecie
						tego call`a (metody ANTY-SI) ale nie zmodyfikowalby 
						w zadany przez nas sposob programu tj. owszem 
						liczyl by klucz, ale nie wlasciwy a wynikiem 
						jego pracy mogloby byc : "Sorry not here..."
Wiec widac juz na pierwszy zut oka gdyby zaistanial skok nie zosta by wpisany wlasciwy ciag bajtow, 
co spowodowaloby wywolywanie niewlasciwej procedury liczacej klucz. Ok wiec nie bedziemy 
zmieniac skokow a tylko dokonamy drobnej korekty 8 bajtow zapisywanych pod adresem 401003, szukamy 
ciagu hex B443CD68663D86F3 i zmieniamy go na B4434048663D86F3. Zmieniajac go w taki sposob 
zapobiegniemy wywolaniu przerwania 68, a w rejestrze ax pozostanie liczba 4301h a po wejsciu 
do call`a zostanie wykonany pozadany przez nas skok. Teraz mamy :

* Reference To: KERNEL32.GetModuleHandleA, Ord:0111h
                                  |
:0040107A E89D050000              Call 0040161C
:0040107F A300304000              mov dword ptr [00403000], eax

* Reference To: KERNEL32.AreFileApisANSI, Ord:0005h <--- zajzyj do turtora CoxoC`a "Dobre crackme"
                                  |
:00401084 E87B050000              Call 00401604
:00401089 83795401                cmp dword ptr [ecx+54], 00000001 <--- flaga 54 :)
:0040108D 1BC0                    sbb eax, eax
:0040108F 40                      inc eax
:00401090 7528                    jne 004010BA <--- nie ruszac, gdy zmienimy skok na przeciwny, nic dobrego z tego nie winikinie NIC. 
:00401092 B810164000              mov eax, 00401610	<--- obacz pod SI
:00401097 A304324000              mov dword ptr [00403204], eax <--- obac zpod SI
:0040109C E8B6010000              call 00401257 <--- w tym call`u mamy SetUnhandledExceptionFilter,
:004010A1 6A00                    push 00000000	     hyh i int 3 :)
:004010A3 68C0104000              push 004010C0
:004010A8 6A00                    push 00000000

* Possible StringData Ref from Data Obj ->"CRACKME1"
                                  |
:004010AA 6804304000              push 00403004
:004010AF FF3500304000            push dword ptr [00403000]

* Reference To: USER32.DialogBoxParamA, Ord:0092h
                                  |
:004010B5 E814050000              Call 004015CE

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401090(C)
|
:004010BA 50                      push eax

* Reference To: KERNEL32.ExitProcess, Ord:0075h <--- sic, dziwne, obacz pod windasm debbuger
                                  |
:004010BB E850050000              Call 00401610
:004010C0 55                      push ebp
:004010C1 8BEC                    mov ebp, esp
:004010C3 817D0C10010000          cmp dword ptr [ebp+0C], 00000110
:004010CA 7538                    jne 00401104


Najpierw sprawdzmy tego call`a gdzie jest SetUnhandled...:


|:0040109C   
|
:00401257 EB07                    jmp 00401260 <--- patchnij to miejsce aby skok wykonal sie do ret`a o adresie xxx:0040125F, czyli EB07 => EB06   
|
:00401257 EB07                    jmp 00401260
:00401259 8B25FC314000            mov esp, dword ptr [004031FC]
:0040125F C3                      ret



* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401257(U)
|
:00401260 8925FC314000            mov dword ptr [004031FC], esp
:00401266 6859124000              push 00401259

* Reference To: KERNEL32.SetUnhandledExceptionFilter, Ord:026Ah
                                  |
:0040126B E8B8030000              Call 00401628 <--- hyhy
:00401270 BD4B484342              mov ebp, 4243484B <--- 'BCHK'
:00401275 B804000000              mov eax, 00000004
:0040127A CC                      int 03 <--- ....
:0040127B 6A00                    push 00000000

* Reference To: KERNEL32.ExitProcess, Ord:0075h
                                  |
:0040127D E88E030000              Call 00401610
:00401282 C3                      ret

:00401259 8B25FC314000            mov esp, dword ptr [004031FC]
:0040125F C3                      ret

Ok teraz po odpaleniu crackme pokazuje sie nam okienko dialogowe Status, Key, itd. Wpisujemy 
byle co i naciskamy register... Ups zamknelo nam crackme. Hmm przyjzyjmy sie temu ExitProcess
po DialogBoxParamA. Odpalamy wdasm debugger i tracujemy do tego miejsca. Heh wdasm sie sypnal.
No to nopnijmy go. Teraz wpiszmy cos w pole key i zastawmy puapke na HmemCpy. Po krotkiej chwili
jestemy w SI tracujemy az dochodzimy do zanjomego miejsca (to jest to drugie wywolanie tej procedury
gdzie znajduje sie sprawdzanie WINICE.BRK i IDT). Z BRK juz sobie poradzilismy teraz przyszedl czas
na IDT. Masz dwie mozliwosci zpatchowac program przy porownaniu cmp eax, 0000001E, badz tez 
uzyc swietnego programiku CookieSICE by CoxoC & massh - ja wybralem program of coz =).
(nie zapominaj o SICE, NTICE & SIWVID;). Pozostaje nam teraz KEY (to co tygrysy lubia najbardziej). Wpisujemy troche smiecia eg. 12qwaszx12, 
zastawiamy pulapke na funckje HmemCpy i naciskamy register. Sledzimy kod i po jakims czasie 
ladujemy w takim miesjcu :
	

:004014C0 BEB5304000              mov esi, 004030B5
:004014C5 33C9                    xor ecx, ecx

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004014CE(U)
|
:004014C7 803C3100                cmp byte ptr [ecx+esi], 00 <---
:004014CB 7403                    je 004014D0			 |
:004014CD 41                      inc ecx			 | ta petla zlicza dlugosc wpisanego
:004014CE EBF7                    jmp 004014C7 <-----------------  ciagu znakow

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004014CB(C)
|
:004014D0 85C9                    test ecx, ecx
:004014D2 0F84DA000000            je 004015B2 <--- gdy dlg. = 0 koniec
:004014D8 890D10324000            mov dword ptr [00403210], ecx
:004014DE 86C1                    xchg cl, al
:004014E0 B104                    mov cl, 04
:004014E2 F6F9                    idiv cl
:004014E4 84E4                    test ah, ah
:004014E6 0F85C6000000            jne 004015B2
:004014EC A221324000              mov byte ptr [00403221], al <--- 32/4=8
:004014F1 BEB5304000              mov esi, 004030B5           <--- I czesc poczatek
:004014F6 33C9                    xor ecx, ecx
:004014F8 8AC8                    mov cl, al
:004014FA 8136ADDEBAAB            xor dword ptr [esi], ABBADEAD
:00401500 83C604                  add esi, 00000004
:00401503 E2F5                    loop 004014FA               <--- I czesc koniec
:00401505 33C0                    xor eax, eax
:00401507 8A0D21324000            mov cl, byte ptr [00403221] <--- II czesc pocz. (8)
:0040150D BEB5304000              mov esi, 004030B5
:00401512 0306                    add eax, dword ptr [esi]
:00401514 83C604                  add esi, 00000004
:00401517 E2F9                    loop 00401512               <--- II czesc kon.
:00401519 8A0D21324000            mov cl, byte ptr [00403221] <--- III czesc pocz.
:0040151F BEB5304000              mov esi, 004030B5
:00401524 3106                    xor dword ptr [esi], eax
:00401526 83C604                  add esi, 00000004
:00401529 E2F9                    loop 00401524		      <--- III czesc kon,
:0040152B BEB5304000              mov esi, 004030B5	      <--- IV czesc pocz.
:00401530 8A0D21324000            mov cl, byte ptr [00403221]
:00401536 BF19314000              mov edi, 00403119
:0040153B 32C0                    xor al, al
:0040153D 8A06                    mov al, byte ptr [esi]
:0040153F 024601                  add al, byte ptr [esi+01]
:00401542 024602                  add al, byte ptr [esi+02]
:00401545 024603                  add al, byte ptr [esi+03]
:00401548 8807                    mov byte ptr [edi], al
:0040154A 47                      inc edi
:0040154B 83C604                  add esi, 00000004
:0040154E E2EB                    loop 0040153B		      <--- IV czesc kon.
:00401550 C60700                  mov byte ptr [edi], 00      <--- V czesc pocz.

* Possible StringData Ref from Data Obj ->"W"
                                  |
:00401553 BE32314000              mov esi, 00403132
:00401558 BF19314000              mov edi, 00403119
:0040155D 8A0D21324000            mov cl, byte ptr [00403221]
:00401563 8A06                    mov al, byte ptr [esi]
:00401565 3007                    xor byte ptr [edi], al
:00401567 46                      inc esi
:00401568 47                      inc edi
:00401569 E2F8                    loop 00401563		      <--- V czesc kon.
:0040156B BF19314000              mov edi, 00403119
:00401570 813F21696D61            cmp dword ptr [edi], 616D6921 <--- yhy
:00401576 753A                    jne 004015B2 <--- huh
:00401578 817F0361676921          cmp dword ptr [edi+03], 21696761 <--- yhy
:0040157F 7531                    jne 004015B2 <--- huh

* Possible StringData Ref from Data Obj ->"Q"
                                  |
:00401581 BF99304000              mov edi, 00403099 <--- VI czesc pocz
:00401586 BEB5304000              mov esi, 004030B5
:0040158B B913000000              mov ecx, 00000013
:00401590 C6461300                mov [esi+13], 00
:00401594 8A07                    mov al, byte ptr [edi]
:00401596 3006                    xor byte ptr [esi], al
:00401598 46                      inc esi
:00401599 47                      inc edi
:0040159A E2F8                    loop 00401594 <--- VI czesc kon.
:0040159C 68B5304000              push 004030B5
:004015A1 68D1070000              push 000007D1
:004015A6 FF3514324000            push dword ptr [00403214]

* Reference To: USER32.SetDlgItemTextA, Ord:0228h
                                  |
:004015AC E84D000000              Call 004015FE
:004015B1 C3                      ret

To jest procka liczaca key`a(druga) - pierwsza jest dla zmylenia (:. Zaczynamy analalize.
Linie :004014C7 do :004014CE to nic innego jak zliczanie ilosci znakow we wpisanym kluczu. 
Pozniej po przejsciu tej czesci mamy dzielenie dlugosci klucza przez 4 i testowanie
rejestru ah (tam umieszczana jest reszta z dzielenia). Czyli dlugosc klucza musi byc podzielna 
przez cztery 4,8,12... analizujac dalej kod mozna zauwazycz ze klucz powinien miec dlugosc 32
znakow. Wpisujemy wiec jakis 32 znakowy klucz - qwasqwasqwasqwasqwasqwasqwasqwas. W I czesci
wpisany klucz jest XOR`owany przez ABBADEADh (kazde 4 bajty - eg. qwas) - 71776173h XOR ABBADEADh 
itd. W II czesci koljne 4 bajty (DWORD) zmodyfikowanego powyzej klucza dodajemy do siebie - operacja
ta tworzy 32 bitowa liczbe, ktora zostanie uzyta w koljne fazie przeksztalacania klucza. W sekcji
III otrzymana liczba 32 bitowa XOR`ujemy 32 bajtowy klucz (wynik czesci I - XOR przez ABBADEADh).
Uff. Dobra jestesmy w czesci IV. Teraz idzie to tak : mamy po poprzedniej operacji 32 bajty teraz
ta czesc dodaje kolejne 4 bajty tworzac z nich 1 liczbe (1 bajtowa) np. 34h+6fh+71h+34h=148h.
Ma zostac nam 1 bajt czyli 148h => 48h (: analogicznie dalej... Po takim przeksztalceniu z 32 
bajtow powstaje 8 bajtow. Kolejna V czesc XOR`uje te 8 bajtow przez 8 bajtow - 57h, 05h, 21h, 1Ah,
FFh, AEh, 99h, 48h. Doooobra jestesmy juz blisko (taaa ;>. Zostalo nam 8 bajtow teraz te 8 bajtow
jest porownywane w liniach :00401570 do :0040157F z 616D6921h i (przesuniecie 3! nie 4) 21696761h.
Sprawdzmy co oznaczaja te liczby ... !imagi! - hehe (Intel of coz)

			21696D61 [edi+03]
 			      61676921 => !imagi!

Zostala nam ostatnia czesc VI. Ta czesc odpowiada ze wyswietlenie napisu w oknie status - moim
taka "dowolnosc" - wyswietlony napis (nie zawsze sensowny) zalezy od wpisanego kodu, a w 
szczegolnosci od pierwszych 20 znakow klucza (13h = 19 :). Napis powastej po XOR`owaniu 20 znakow
klucza z 51h, 13h, 4Eh, A1h, 00h, 57h, 17h ACh, 75h, 17h, 49h, ACh, 62h, 12h, 5Dh, E1h, 54h, 0Dh,
00h, 00h.

[Protokol]
Jak to odwrocic, zeby w oknie status pokazal sie w miare sensowny napis ?.
Wiemy ze wynik calego "mieszania" ma byc !imagi!. WIemy ze XOR dziala w dwie strony wiec robimy
tak :
			5705211AFFAE9948
		XOR	21696D6167692100 => 
			----------------
			766C4C7B98C7B848 => tak powinno wygladac 8 bajtow po V czesci programu

			Czyli kazda liczba (1 bajt) to suma 4 innych bajtow hyhyh :>

Teraz przejdzmy do tego napisu w oknie status (nie nadarmo mamy 20 bajtowa podpowiedz). Dzieki
temu mozemy ustalic klucz... Jak wiemy i mamy wypisane wyzej kazda z DWORD powinna miec sume jak
w dzialaniu powyzej a wiec ustalmy sobie jaki napis sie ma pojawic w oknie status, zostawiajac 
"rezerwe" aby dobrac odpowiednie wartosci ktore po zsumowaniu dadza pozadana wartosc.

      51134EA1 005717AC 751749AC  62125DE1 540D0000
 XOR    r   e    g   i    s   t     e   r    e   d
     ----------------------------------------------
      xx61xxC4 xx30xxC5 xx64xxD8  xx77xx93 xx68xx64        xxxxxxxx

      ^=76h    ^= 6Ch   ^=4Ch     ^=7Bh    ^=98h ......... ^=48h - hyh

Proste ? Teraz dobieramy tak dobieramy liczby w miesca xx aby sumy kolejnych 4 bajtow odpowiadaly 
wartoscia 76h, 6Ch, 4Ch, 7Bh, 98h, C7h, B8h, 48h - powstanie przez to troche smiacia na w oknie,
ale nasz napis bedzie dal sie odczytac (:. miejsca xx uzupelniamy liczbami ktore po kolejnym dodaniu
do siebie dadza nam oczekiwany wynik.

      45610CC4 453032C5 4564CBD8  45772C93 45689754 | 45303022 45303211 | 12772C93 		

      ^=76h    ^=6Ch    ^=4Ch	  ^=7Bh	   ^=98h      ^=C7h    ^=B8h	  ^=48h

Wiec teraz nalezy napisac krotki programik ktory znajdzie nam prawidlowy key. Jak ? ...
Wiec czytajac ten zagmatfany (tzn nie jasno wytlumaczony) sposob tworzenia key`a napiszmy program,
ktory pozwoli nam uzyskac jakis napis w oknie status - eg. "zasmiecony" registered. Powyzej
przedsatwione mam obrane przezemnie wartosci. Teraz dla tych wartosci musimy zastosowac takie 
dzialanie : 
	(X)={[(suma osmiu 4 bajtowych fragmentow tego lancucha)*]  XOR lancuch } XOR ABBADEAD

gdzie:
	(X)= to prawidlowy lancuch, ktory wyswietli nam takie pokrecone - zasmiecone registered
	*suma.. - to nasza szukana. Mamy lancuch juz po operacji wiec musimy obliczyc liczbe,
		po XOR`owaniu ktora wynikiem bedzie nasz ciag wartosci [ 45610CC4 ....]
	
		   
A oto slaby programik (wykonuje sie trooche czasu :]) :

dana - nasz lancuch wartosci na ktorym bedziemy operowac [ 45610CC4 ....]
dana1 - ten lancuch wartosci, sluzacy nam do otworzenia pierwotnych wartosci po operacjach
	matematyznych
Zmienna - pomocnicza

	xor	ecx,ecx 	
@petla:
	mov   	edx, 0
	add	ecx, 1
	push 	ecx
	mov 	edx, ecx 
	mov   	ecx, 8
	mov	esi, offset dana	
@petla1:
	xor 	dword ptr[esi], edx
	add	esi, 4
	loop	petla1

	mov	ecx, 8
	mov	eax, 0
	mov	esi, offset dana
@ptl2:	
	add	eax, dword ptr[esi]
	add	esi, 4
	loop	ptl2

	mov 	Zmienna, eax
	pop 	ecx
	cmp 	ecx, eax
	jz	@Good
	push 	ecx
	mov 	ecx, 32
	mov 	edx ,0 
	mov 	esi, offset dana1
	mov	edi, offset dana
 @ptl3:
	mov	dl, byte ptr[esi]
	mov	byte ptr[edi], dl
	add 	esi, 1
	add	edi, 1
	loop 	@ptl3
	
	pop	ecx
	cmp	ecx, 0FFFFFFFEh
	jz 	Bad
	jmp 	@petla

@Good:
     	[...]
	Tu XOR`owany bedzie prawidlowy lancuch przez ABBADEAD i wyswietlany stosowny komunikat.
@Bad:
	[...]
	Tu komunikat o nieznalezieniu wlasciwej "sumy" - nie zawsze jest rozwiazanie

To byl wlasnie ten lame programik. Wynikiem jego dzialania jest :
	
	73h,D4h,69h,20h,73h,85h,57h,21h,73h,D1h,AEh,3Ch,73h,C2h,49h,77h,73h,DDh,
	F2h,B0h,73h,85h,55h,C6h,73h,85h,57h,F5h,24h,C2h,49h,77h

	... of coz sa to wartosci HEX kodow ASCII. Napis wyszedl nie ciekawie, ale to juz
	nie moj problem (;

------------------------------------------------------------------------------------------------
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Greetings : CookieCrK & #crackpl



