-----------------------------------------------------------------------
target:Matrix v1.0
czym  :SoftIce v4.xx,DeDe,Hiew,Cracker Inquisitor,RegMon,i cala reszta
skad  :www.crackmes.prv.pl
opis  :crackme by Mr. Ketchup
kto   :Sawka
e-mail:ssawek@poczta.onet.pl
-----------------------------------------------------------------------

Znalazlem na dzis calkiem ciekawy crackme.
Oto co kaze zrobic nam tworca:

(...)
Crackers Matrix ma kilka leveli.
1) Code -             Tutaj jest zwykly password. Aby zaliczyc ten 
                      poziom nalezy przyslac mi ten kodzik.
2) Name/Code -        Czyli wygeneruj code dla swojego name. Aby 
                      zaliczyc poziom podeslij mi KeyGen
3) KeyFile -          Pliczek rejestracyjny. Znowu aby zaliczyc nalezy 
                      napisac prog co bedzie generowal ten plik.
4) Code harder -      To samo co w jedynce ale troszke trudniejsze.
5) Name/Code harder - Zerknij do punktu 2 i pomysl sobie ze to jest 
                      troszke trudniejsze.
6) KeyFile harder -   No chyba sami wiecie ze macie isc do punktu 3) :)
7) CheckBox -         Poziom jest zaliczany po napisaniu keygena.
8) NagScreen -        Nalezy pozbyc sie tego Naga. Jednym slowem napisz 
                      patcher.
9) ID/Code -          Do losowego ID wygenerowac trzeba code. Tutaj 
                      takze trzeba napisac keygen aby zaliczyc level
10) Your PC Code -    W tym levelu nalezy podac tylko kod ktory jest 
                      inny na kazdym kompie. Standardowo wymagany jest 
                      keygen aby rozwiazanie bylo poprawne.

Jest jeszcze jedno zabezpieczenie. Nalezy wlaczyc nieaktywne kuleczki 
przy nazwach leveli.Tutaj musisz napisac patch.
(...)

Noi co wy na to?...niezly kawal roboty przed nami:)...Taka nasza dola.
Ale pomysl za to jaka bedzie satysfakcja po takiej wyczerpujacej 
robocie!!

Zaczynamy:
===========
1.Rozpakowywanie i uruchomienie.

Przyjrzyjmy sie temu matrix-owi. Na pierwszy rzut oka widac, ze jest 
spakowany. Jesli dasz podglad tego pliku, to dowiesz sie, ze jest 
pakniety UPX 1.01. No to trzeba go rozpakowac, bo przeciez musimy robic
potem zmiany w pliku. Wrzucamy matrixa do upx i wydajemy polecenie:
upx -d matrix.exe
...program nam sie grzecznie rozpakowal (zauwaz,ze plik ma teraz ponad
460kb). Sprobujmy uruchomic teraz ten pliczek...heh...noi co?...nie da
rady?!? Matrix zostal napisany z mysla o crackerach i tak latwo sie nam
nie da:)) Crackme, jak sie pewnie juz domyslasz zostalo zabezpieczone
przed softicem i nie uruchamia sie w jego obecnosci!! Jak to obejsc?...
pomysl...mozemy przeciez skorzystac z FrogIce! Uruchamiamy Froga i 
wylaczmy w opcjach "BlueScreenOfDeath". Zapuszczamy matrixa i co? Znow
sie nie uruchomil!!! Kurde co jest grane. Jak mozna wykryc jeszcze 
obecnosc SI?...heh...przez wpisy rejestrze! Uruchamiamy Regmona i w
filtrze wpisujemy "matrix". Zapuszczamy matrix-a i Regmon nam 
grzecznie napisal:

Matrix  OpenKey          HKLM\Software\NuMega\SoftIce         SUCCESS
Matrix  QueryValueEx    HKLM\Software\NuMega\SoftIce\InstallDir SUCCESS
Matrix  CloseKey HKLM\Software\NuMega\SoftIce            SUCCESS
 
...czyli to jest to!! Wiec uruchamiamy Edytor Rejestru i zmieniamy 
klucz NuMega na np. Nu-Mega i po wszystkim. Matrix nam sie teraz
uruchamia.

2.Odblokowanie nieaktywnych radiobuttonow.

Co teraz widzimy? Wszystkie kuleczki z poziomami sa wylaczone, a z boku jest
napis "Enable Me". Wiec zabieramy sie za to. Wrzucamy Matrix-a do WDasma i
patrzymy co mamy w SDR...heh...to sa jakies smieci!!! Kurde!! No ale spoko.
Z progrow tworzonych w jakim jezyku nie mozemy odczytac SDR???...hmm...pomyslmy
...moze Delphi?... wrzucamy matrixa do File Analizera i juz jestesmy pewni ze prog
jest napisany w Delphi. Nawet wystarczy spojrzec na wielkosc pliku - progi
w asmie sa mniejsze...duzo mniejsze:) OK...potrzebujemy jakis dekompilator Delphi...
proponuje skorzystac z DeDe. Wrzucamy Matrixa i naciskamy Process (Pamietaj, zeby
miec wtedy wlaczonego FrogIce, bo inaczej Matrix sie nie uruchomi i DeDe sypnie
bledem!)...po chwili mamy juz rozlozonego Matrixa na czynniki pierwsze
(tzw. kontrolki). Teraz sprawdz czy masz w DeDe zaladowane symbole, jesli nie, to
zrob to. OK. Przechodzimy na zakladke Procedures. W lewym okienku mamy nazwy 
"unit"-ow. Nas interesuje Unit1...dlaczego...zobacz na Unit2 i popatrz w
prawe okienko...co tam widzisz...jakies smieci...po prostu intuicja mowi mi, ze
trzeba tego szukac w Unit1:) Naciskamy wiec na Unit1 i w lewym oknie mamy nazwy
procedur, jakie maja zostac odpalone po wykonaniu przez uzytkownika okreslonych
czynnosci (np. nacisniecie przycisku). Popatrzmy na nie...interesujaco wyglada
FormCreate...znow intuicja. Klikamy na to wiec i pokazuje sie nam nowe okienko z
kodem. Przesuwamy suwak w dol i zapoznajemy sie z kodem...w pewnym momencie 
widzimy cos ciekawego:

0045EB44   8B83EC020000           mov     eax, [ebx+$02EC]

* Reference to: controls.TControl.SetVisible(TControl;System.Boolean);
|
0045EB4A   E87979FCFF             call    004264C8

* Reference to control TForm1.RadioGroup1 : TRadioGroup
|
0045EB4F   8B83D0020000           mov     eax, [ebx+$02D0]
0045EB55   8B10                   mov     edx, [eax]

* Possible reference to virtual method TRadioGroup.OFFS_4C
|
0045EB57   FF524C                 call    dword ptr [edx+$4C]
0045EB5A   3C01                   cmp     al, $01
0045EB5C   0F8598000000           jnz     0045EBFA   <<...to ciekawe


...wczytaj sie w ten kod...nie przerazaj sie...ja tez nie znam Delphi:)
...po prostu staraj sie go zrozumiec na swoj sposob. Widzimy tam jakas funkcje
SetVisible, czyli ustawianie czego zeby bylo widoczne:)...ok... dalej mamy
TRadioGroup, czyli mozna zrozumiec, ze to dotyczylo naszych radiobox-ow...dalej
mamy jakis skok...heh co mi zalezy, zeby sprawdzic co ten skok robi?...moze cos
ciekawego znajdziemy?:) Spisujemy adres, czyli 0045EB5C i wchodzimy do Cracker
Inquisitor, wklepujemy adres w wolne pole i otwieramy nasz plik - mamy w ten
sposob offset :5DF5Ch. Uruchamiamy Hiew i zmieniamy skok pod tym offsetem na
przeciwny. Teraz odpal Matrixa i co?...obok radiobutton-ow pojawil sie napis
"Good Job", ale buttony dalej sa wylaczone:( hmm...to znaczy,ze jestesmy blisko:)
Zmieniamy ten skok na taki jak byl wczesniej i myslimy co z tym zrobic. ...myslimy
...myslimy...i co?...nie ciekawi cie co sie dzieje w procedurce pod adresem 0045EB57?
...,bo mnie tak:) Skorzystajmy wreszcie z SI:)...spisujemy sobie adres na kartke i
lecimy do SI. Zakladamy pulapke na np. hmemcpy, czyli:

bpx hmemcpy

i uruchamiamy Matrix-a...i co?...znow w SI:)...Sprawdz jaki program zlapal sie na pulapke(prawy,dolny rog)...jesli Matrix, to cool, jesli nie to F5.Ok...Teraz wylaczamy
pulapke:

bd *             

...i lecimy dalej...musimy sie dostac do kodu Matrixa...czyli naciskamy F12, dopoki tam
nie trafimy. Juz?...no to tym razem ustawiamy pulapke na adres:

bpx 0045EB57

i naciskamy F5...chwila przerwy i znow w SI...w takim miejscu:

017F:0045EB57   CALL      [EDX+4C]
017F:0045EB5A   CMP       AL,01
017F:0045EB5C   JNZ       0045EBFA

...znajomo:)...no pewnie!...wiec wchodzimy do tego CALL-a, czyli F8 i mamy:

017F:00425940   MOV       AL,[EAX+48]
017F:00425943   RET

...huh...juz lepiej...pomysl...program na podstawie wartosci pod jakims adresem stwierdza,
czy napisac "Good Job", czy "Enable Me"...chyba sie ze mna zgadzasz...przemysl to!!...
rozumiesz?...na pewno. A teraz uwazaj ...jesli na podstawie tego adresu program pisze
odpowiedni napis, to czy nie moze stwierdzac tez czy wlaczyc i wylaczyc radioboxy?...mysle, 
ze tak!!...no dobra, ale jak sie dostac do tego miejsca w programie? ...ano prosto...trzeba, bedac w lini 00425940 zalozyc pulapke na adres, czyli:

bpm eax+48

...chyba chwytasz mysl?...pulapka ta przerwie nam wykonywanie programu gdy cos bedzie robione
z ta komorka pamieci...moze nawet uda nam sie trafic do miejsca, gdzie wpisaywana jest tam wartosc, ktora wylacza radioboxy i sypie glupie napisy:)))...puszczamy dalej Matrix-a i
...nic ...ale zaraz crackme pewnie na poczatku ma procke, ktora to sprawdza. Wiec wylaczmy
Matrix i wlaczmy ponownie...za ktoryms razem SI przerwie ci proga w tym miejscu:

017F:0042650C    CMP       DL,[EAX+48]
017F:0042650F    JZ        00426522         <<calkiem ciekawy skok:))
017F:00426511    MOV       [EAX+48],DL
017F:00426514    PUSH      00
017F:00426516    XOR       ECX,ECX
017F:00426518    MOV       EDX,0000B00C
017F:0042651D    CALL      0042754C

...hmm...podmienmy ten skok na przeciwny (2590Fh)...i co?...i dziala... mamy full sprawnego Matrixa:))))Widzisz...tak trudne zadanie okazalo sie zupelnie proste...na prawde,nie ma co sie przerazac roznych zabezpieczen...wszystko jest do zlamania, to tylko kwestia czasu:))
Wystarczy tylko intuicja i troche samozaparcia:)

3.Anti Anti;)

No dobra,teraz proponuje wywalic z Matrixa wszystkie procki, ktore wykrywaja SI...chyba
wkurzaja ciebie tak samo jak mnie:) Ale zanim to zrobimy proponuje ci zebys cos sprawdzil...
sprobuj wlaczyc np. WDasm, a potem uruchom Matrix-a...i co sie stalo...heh...zamknelo nam Wdasm-a. Niezle co?...czyli crackme nie tylko wykrywa SI, ale takze i inne progi.
Podpowiem ci jak to robi...wykonuje funkcje: FindWindowExA, zeby odnalezc okienko o okreslonej nazwie, a nastepnie, jesli znajdzie, to "zabija" nam proces i po bolu;) No to spoko juz wszystko wiemy.Wchodzimy do SI i stawiamy pulapke:

bpx findwindowexa

...i uruchamiamy Matrix-a...noi cool jestesmy znow w SI...

017F:0045EC06     TEST      EAX,EAX
017F:0045EC08     JMP       0045EC4D
017F:0045EC0A     PUSH      0045ED10
017F:0045EC0F     PUSH      00
017F:0045EC11     CALL      USER32!FindWindowA
017F:0045EC16     MOV       EBX,EAX
017F:0045EC18     PUSH      EBX

...pod adresem 0045EC08 jest jmp ktory przenosi nas tu:

017F:0045EC4D     MOV       AH,43
017F:0045EC4F     INT       68
017F:0045EC51     CMP       AX,F386
017F:0045EC55     JZ        KERNEL32!ExitProcess
017F:0045EC5B     MOV       DL,01
017F:0045EC5D     MOV       EAX,[004486D0]

...ok jesli wiesz troche o sposobach wykrywania SI, to chyba kleisz co i jak...jesli nie, to potlumacze...jesli w systemie znajduje sie debugger, to gdy wywolamy przerwanie 68 (INT 68) przy AH=43h, to do rejestru AX zostanie zwrocona wartosc 0F386...teraz juz chyba rozumiesz dlaczego nie mozemy pozwolic na to zeby ten kawalek kodu byl w Matrix-ie;)...ok...spisujemy offset z Cracker Inquisitor(5E04Dh) i nop-ujemy najlepiej wszystko od adresu 0045EC4D do 0045EC5A.Teraz 
juz crackme wykrywa tylko SI za pomoca kontroli rejestrow. No to sprubujmy to tez wywalic. Zakladamy pulapke:

bpx RegQueryValueExA

zmieniamy klucz w rejestrze na taki jaki byl wczesniej (NuMega) i uruchamiamy Matrix-a...za drugim razem ladujemy tu:

017F:00448A2A     CALL      ADVAPI32!RegQueryValueExA
017F:00448A2F     TEST      EAX,EAX
017F:00448A31     SETZ      BL         <<zawsze mozna zrobic SETNZ BL:)
017F:00448A34     MOV       EAX,[ESP]
017F:00448A37     CALL      004487A8
017F:00448A3C     MOV       [EBP+00],AL

Dobra...wykrywanie SI polega tu na tym, ze Matrix probuje otworzyc klucz "HKLM\Software\NuMega\SoftIce\InstallDir"...jesli mu sie to uda, to funkcja RegQueryValueExA zwraca wartosc 0 i my oczywiscie tego nie chcemy...teraz nacisnijmy dwa razy F12 i jestesmy tu:

017F:0045EC9B     TEST      AL,AL
017F:0045EC9D     JZ        0045ECB0   <<< ciekawy skok:))
017F:0045EC9F     MOV       EAX,[00463A30]
017F:0045ECA4     CALL      00402D54

...chyba chwytasz, ze jesli zmienimy oznaczony skok na bezwarunkowy, to zrobimy proga w jajo i cala procka otwierania klucza na nic sie zda:) ...edytujemy pod offsetem 5E09Dh...zmieniles skok na jmp?...i co pewnie dziala;) Teraz nasz krakerski matrix uruchamia sie w naszych domowych warunkach bez pomocy FrogIce i bez wzgledu na wyglad rejestrow. A teraz uwaga!!! Twoje zadanie domowe...wiesz juz jakiej funkcji uzywa Matrix zeby wykryc aktywnosc WDasma...wiec w nagrode "przerob" crackme, zeby nie wykrywalo ani WDasm ani The Customisera:)) To na prawde proste!!!

4.Poziom 1.

Tymczasem mozemy juz przejsc do pierszego poziomu crackme: Code. Chyba nie musze pisac od czego trzeba zaczac...;)...jasne...wpisujemy jakis numerek i stawiamy pulapke na np:

bpx hmemcpy

...i znow w SI...teraz kilka razy F12 i F10 i taki kod przed soba widzimy:

017F:0045D6F8   MOV       EAX,[00463834]   ;tu offset do naszego s/n
017F:0045D6FD   MOV       EDX,[00463848]   ;wpsuje 01h
017F:0045D703   MOV       AL,[EDX+EAX-01]  ;do al pierwsza cyfra/znak
017F:0045D707   MOV       [EBX],AL         ;al wpisuje pod inny offset
017F:0045D709   MOV       AL,[EBX]         ;hmm...bezsensu...;)
017F:0045D70B   XOR       AL,0D            ;xor pierwszego znaku z 0dh
017F:0045D70D   MOV       [EBX],AL         ;wynik idzie pod inny offset
017F:0045D70F   ADD       BYTE PTR [EBX],0C;dodaje do wyniku 0ch
017F:0045D712   MOV       AL,[EBX]         ;wynik wraca do al
017F:0045D714   XOR       AL,2D            ;---------------------------
017F:0045D716   MOV       [EBX],AL         ;
017F:0045D718   ADD       BYTE PTR [EBX],14;troche operacji matematycz
017F:0045D71B   MOV       AL,[EBX]         ;nych..mysle ze je rozumiesz
017F:0045D71D   XOR       AL,32            ;
017F:0045D71F   MOV       [EBX],AL         ;
017F:0045D721   ADD       BYTE PTR [EBX],1E;---------------------------
017F:0045D724   LEA       EAX,[EBP-08]     ;
017F:0045D727   MOV       DL,[EBX]         ;
017F:0045D729   CALL      00403B84         ;powiem ci tylko,ze ta czesc
017F:0045D72E   MOV       EDX,[EBP-08]     ;kodu powoduje zapisanie
017F:0045D731   MOV       EAX,00463838     ;wyniku pod offset w pamieci
017F:0045D736   CALL      00403C64         ;
017F:0045D73B   INC       DWORD PTR [00463848] |
017F:0045D741   DEC       ESI                  |i petelka sie kreci;)
017F:0045D742   JNZ       0045D6F8             |

...mysle ze wszystko jasne:)...popatrz na te wszystkie operacje matematyczne na kolejnych znakach...te ciagle przepisywanie wyniku do pamieci i do rejestru tylko przeszkadza...jesli sie wczytasz w kod, to zrozumiesz,ze mozna to zapisac w taki sposob:

xor al,0d
add al,0c
xor al,2d
add al,14
xor al,32
add al,1e

...zgadzasz sie ze mna?...na pewno...teraz wszystko jest bardziej przejrzyste i czytelne.Wiec powyzsza czesc kodu po prostu przeksztalca nasz wpisany numerek.No dobra to lecimy dalej, dochodzimy do takiego miejsca:

017F:0045D744     MOV       EAX,[00463838] <<tu nasz zmieniony serial
017F:0045D749     MOV       EDX,0045D7F8   <<tu poprawny serial
017F:0045D74E     CALL      00403D6C       <<zobacz sam:)..typowa proc.
017F:0045D753     JZ        0045D784       <<bad/good

...wiemy juz wszystko...aby uzyskac poprawny serial w linii 0045D749 dajemy:

d edx

i mamy ciag: 64,79,7C,82,79,38,DC,0E,61,7D,AB,77,0E,11,82,79,38,5E,7D,
A7,AC,38,5E,79,5F,38,5F,AB,61,79,AC,38,CE,45,21.

Czyli to musimy uzyskac po przeksztalceniu haselka...wiec jak uzyskac haslo?...proscizna,trzeba po prostu odwrocic wszystkie operacje matematyczne na hasle i zamiast hasla wpisac powyzszy ciag...heh... zamotalem, ale chyba kleisz co i jak:)...przypomne nasze operacje matematyczne wygladaly tak:

xor al,0d
add al,0c
xor al,2d
add al,14
xor al,32
add al,1e

...odwracamy je(od konca!):

sub al,1e
xor al,32
sub al,14
xor al,2d
sub al,0c
xor al,0d

...za al podstawiamy 64h (pierwsza liczba z naszego ciagu) i obliczamy:

:?64-1e
00000046  0000000070  "F"
:?46^32
00000074  0000000116  "t"
:?74-14
00000060  0000000096  "`"
:?60^2d
0000004D  0000000077  "M"
:?4d-0c
00000041  0000000065  "A"
:?41^0d
0000004C  0000000076  "L"

...czyli otrzymalismy pierwszy znak...litera "L"...reszta zabawy nalezy do ciebie...wszystko robi sie tak samo:)...jesli chcesz mozesz napisac proga, ktory zrobi to za ciebie...mozliwosci jest sporo:)...ja moge tylko powiedziec, ze zgadzam sie z autorem haselka:))))) ...i pierwszy poziom za nami...lecimy dalej.

5.Poziom 2

Teraz mamy zabezpieczenie name/code...no to do dziela...podpowiem,ze sytuacja jest podobna do poprzedniego poziomu, tylko zamiast stalego ciagu poprawnego haselka, jest zmienny - generowany na podstawie name. Proponuje ci sprobowac sil samemu, jesli sie nie powiedzie, to czytaj dalej:)
Wpisujemy name...minimum 7 znakow(potem pokaze dlaczego) i code:

name:Sawka is OK
code:1234567890

i zakladamy pulapke:

bpx hmemcpy

i dajemy zeby sprawdzil kod...i znow w SI:

017F:0045CEEF    MOV       EDX,[EBP-04]
017F:0045CEF2    MOV       EAX,0046383C
017F:0045CEF7    CALL      00403A30
017F:0045CEFC    MOV       EAX,[0046383C]
017F:0045CF01    CALL      00403C5C   <<do eax trafia dlugosc name
017F:0045CF06    CMP       EAX,07
017F:0045CF09    JGE       0045CF4D  <<jesli krotsze niz 7 znakow - zle

dalej mamy to:

017F:0045CF67    MOV       EAX,[0046383C]    ;offset do naszego name
017F:0045CF6C    MOV       EDX,[00463848]    ;do edx licznik(do petli)
017F:0045CF72    MOV       AL,[EDX+EAX-01]   ;do al pierwszy znak name
017F:0045CF76    XOR       AL,0A             ;xor pierwszy znak z 0ah
017F:0045CF78    MOV       [EBX],AL          ;wpisz wynik gdzies tam;)
017F:0045CF7A    ADD       BYTE PTR [EBX],1E ;dodaj do niego 1eh
017F:0045CF7D    MOV       AL,[EBX]          ;i przerzuc to do al
017F:0045CF7F    XOR       AL,0C             ;xor al,0c
017F:0045CF81    MOV       [EBX],AL          ;przerzuc gdzies:))
017F:0045CF83    ADD       BYTE PTR [EBX],18 ;-------------------------
017F:0045CF86    SUB       BYTE PTR [EBX],0E ;
017F:0045CF89    ADD       BYTE PTR [EBX],2D ;
017F:0045CF8C    SUB       BYTE PTR [EBX],10 ;
017F:0045CF8F    ADD       BYTE PTR [EBX],1E ;tu troche dodawania,
017F:0045CF92    SUB       BYTE PTR [EBX],18 ;odejmowania i xor-owania
017F:0045CF95    ADD       BYTE PTR [EBX],32 ;
017F:0045CF98    SUB       BYTE PTR [EBX],15 ;
017F:0045CF9B    MOV       AL,[EBX]          ;
017F:0045CF9D    XOR       AL,18             ;
017F:0045CF9F    MOV       [EBX],AL          ;
017F:0045CFA1    SUB       BYTE PTR [EBX],06 ;
017F:0045CFA4    ADD       BYTE PTR [EBX],05 ;
017F:0045CFA7    ADD       BYTE PTR [EBX],0E ;-------------------------
017F:0045CFAA    LEA       EAX,[EBP-08]         |
017F:0045CFAD    MOV       DL,[EBX]             |
017F:0045CFAF    CALL      00403B84             |
017F:0045CFB4    MOV       EDX,[EBP-08]         |uwierz mi na slowo, ze
017F:0045CFB7    MOV       EAX,00463834         |ta czesc kodu wpisuje
017F:0045CFBC    MOV       ECX,[00463834]       |wynik do pamieci i 
017F:0045CFC2    CALL      00403CA8             |powieksza licznik...
017F:0045CFC7    INC       DWORD PTR [00463848] |jesli chcesz analizuj
017F:0045CFCD    DEC       ESI                  |
017F:0045CFCE    JNZ       0045CF67             ;petla sie kreci:))))

...to jest procka kodujaca name...zapiszmy to w prostszej postaci jak poprzednio:

xor al,0ah
add al,1eh
xor al,0ch
add al,2dh
sub al,15h
sub al,0eh
add al,32h
sub al,10h
sub al,18h
add al,1eh
add al,18h
xor al,18h
add al,05h
add al,0eh
sub al,06h

...z name otrzymalem wynik:92,AE,A3,0A,DC,A3,E4,B2,06,E4,EA.
Lecimy dalej...mamy takie cos:

017F:0045CFE6    CALL      00403A30
017F:0045CFEB    MOV       EAX,[00463840]
017F:0045CFF0    CALL      00403C5C    <<w eax dlugosc code
017F:0045CFF5    CMP       EAX,03      <<jesli mniej niz 3 to zle
017F:0045CFF8    JGE       0045D03C

...dalej mamy takie cos:

017F:0045D0A7    MOV       EAX,[00463840]
017F:0045D0AC    MOV       EDX,[00463848]
017F:0045D0B2    MOV       AL,[EDX+EAX-01]
017F:0045D0B6    XOR       AL,0A
017F:0045D0B8    MOV       [EBX],AL
017F:0045D0BA    ADD       BYTE PTR [EBX],1E
017F:0045D0BD    MOV       AL,[EBX]
017F:0045D0BF    XOR       AL,0C
017F:0045D0C1    MOV       [EBX],AL
017F:0045D0C3    ADD       BYTE PTR [EBX],2D
017F:0045D0C6    SUB       BYTE PTR [EBX],15
017F:0045D0C9    SUB       BYTE PTR [EBX],0E
017F:0045D0CC    ADD       BYTE PTR [EBX],32
017F:0045D0CF    SUB       BYTE PTR [EBX],10
017F:0045D0D2    SUB       BYTE PTR [EBX],18
017F:0045D0D5    ADD       BYTE PTR [EBX],1E
017F:0045D0D8    ADD       BYTE PTR [EBX],18
017F:0045D0DB    MOV       AL,[EBX]
017F:0045D0DD    XOR       AL,18
017F:0045D0DF    MOV       [EBX],AL
017F:0045D0E1    ADD       BYTE PTR [EBX],05
017F:0045D0E4    ADD       BYTE PTR [EBX],0E
017F:0045D0E7    SUB       BYTE PTR [EBX],06
017F:0045D0EA    LEA       EAX,[EBP-10]
017F:0045D0ED    MOV       DL,[EBX]
017F:0045D0EF    CALL      00403B84
017F:0045D0F4    MOV       EDX,[EBP-10]
017F:0045D0F7    MOV       EAX,00463838
017F:0045D0FC    MOV       ECX,[00463838]
017F:0045D102    CALL      00403CA8
017F:0045D107    INC       DWORD PTR [00463848]
017F:0045D10D    DEC       ESI
017F:0045D10E    JNZ       0045D0A7

...kurde jakies to wszystko znajome...przeciez taka sama procka byla dla name!!!...pomysl to jaki musi byc code zeby wyniki byly takie same? ...jasne!!!...name i code musza byc po prostu identyczne..hehe...ale walek;))) Wystarczy tylko zeby name byl dluzszy niz 7 znakow. No dobra,
ale autor kaze nam zrobic keygena...jesli znasz asma, to do tutora jest dolaczony plik key_2.asm...wszystko jest w nim wyjasnione...jesli nie znasz asma, to ucz sie jak najszybciej...wystarcza ci tylko podstawy, zeby napisac keygena...sam znam asma slabo, ale jakos sobie radze:)))

6.Poziom 3

No poziom trzeci juz czeka:))...lecimy;)
Ten level jest tylko na pozor trudny. Musimy w nim wygenerowac KeyFile dla naszej xywki, potem jeszcze napisac KeyGena. Najpierw trzeba by sie dowiedziec jak ma sie nazywac ten plik-klucz i ewentualnie gdzie powinien sie znajdowac...a wiec do dziela;)...w SI zakladamy pulapke
na funkcje CreateFileA - jest to typowa funkcja do otwierania/tworzenia/itd. plikow:

bpx createfilea do "d esp->4;p ret"

...ta czesc po do jest to takie mini-makro...po prostu ma ono za zadanie ukazanie nazwy otwieranego pliku w okinie danych w momencie zadzialania pulapki. OK. Pulapke juz mamy, wiec przechodzimy w matrixie na poziom trzeci, zeby sprawdzil poprawnosc pliku...i znow w SI,ale w
oknie danych widzimy cosik ciekawego...matrix.dat...w oknie kodu mamy:

017F:0040550B   CALL      KERNEL32!CreateFileA
017F:00405510   CMP       EAX,-01
017F:00405513   JZ        00405604

...o co tu chodzi?...ano o to, ze jesli cretefilea znajdzie plik matrix.dat , to zwroci wartosc rozna od 0ffffffffh...wiec w naszym przypadku jesli sie jej nie uda, to skok pod adresem 00405513 wykona sie i po bolu;) Wiec tworzymy sobie plik matrix.dat i wpisujemy do nigo np. 1234567890 uruchamiamy matrixa i ty razem wszystko jest ok. Naciskamy F10, bo nic ciekawego nie widac, az do tego momentu:

017F:0045D33E   CALL      004027BC
017F:0045D343   MOV       EAX,[00463834]
017F:0045D348   CALL      00403C5C   ;do eax idzie dlugosc pliku
017F:0045D34D   CMP       EAX,05     ;jesli krotszy niz 5 to bad
017F:0045D350   JG        0045D384

...to proste...sprawdza czy jest odpowiednio dluga nazwa w pliku. Idziemy dalej, mamy to:

017F:0045D389   CALL      00403C5C  ;zwraca jaka liczbe do eax (???)
017F:0045D38E   CMP       EAX,05    ;jesli mniej niz 5 to zle(u nas 0)
017F:0045D391   JG        0045D3C5  ;noi po nas;)

...co to moze byc za wartosc w eax?...wychodzi na to, ze kod w pliku sklada sie z jakis dwoch czesci i ze musza byc one oddzielone jakims znakiem...nie bede ci tlumaczyl jak do tego doszedlem, bo to troche zamotane(jesli chcesz, to sam sie pobaw), ale tym znakiem jest 0dh, a
plik powinien byc zakonczony 1ah...musisz mi uwierzyc na slowo:))) a wiec uzupelniamy nasz plik:

1234567890"0dh"abcdefgh"1ah"

nie sugeruj sie moim zapisem!!!...napisalem tak zeby ci to wszystko tylko zobrazowac...zamiast "0dh" i "1a" musisz wpisac wartosci w jakims hex edytorze np. hiew...bedzie to wygladac tak:

1234567890
abcdefgh

!!!!to wazne!!!!!
OK. Teraz juz jest troche lepiej. Dwa skoki sie wykonuja i jest dobrze:)) Lecimy F10 az do takiego miejsca:

017F:0045D420    MOV       EAX,[00463838]  ;w eax offset do II cz. kodu
017F:0045D425    MOV       EDX,[00463848]
017F:0045D42B    MOVZX     EAX,BYTE PTR [EDX+EAX-01]
017F:0045D430    ADD       [00463A20],EAX
017F:0045D436    XOR       DWORD PTR [00463A20],0C
017F:0045D43D    ADD       DWORD PTR [00463A20],000000FB
017F:0045D447    SHR       DWORD PTR [00463A20],1
017F:0045D44D    IMUL      EAX,[00463A20],64
017F:0045D454    MOV       [00463A20],EAX
017F:0045D459    INC       DWORD PTR [00463848]
017F:0045D45F    DEC       EBX
017F:0045D460    JNZ       0045D420

Chyba sam widzisz co tu jest robione, ale ja jak zwykle podpowiem... taka ma robota;)) Z kolejnych znakow drugiej czesci kodu generowana jest liczba i zapisywana jest pod adresem 00463A20. Procka znow jest nie czytelna, wiec troche ja przeksztalcmy, a tak...dla treningu;)
Proponuje zrobic sama procke tylko na rejestrach, a nie bawic sie w offsety w pamieci...czyli:

xor esi,esi
xor eax,eax
mov ecx,offset 2_cz_kodu
mov al,[ecx]
add esi,eax
xor esi,0ch
add esi,0fbh
shr esi,1
imul eax,esi,64  ;tak dla wyjasnienia...to jest mnozenie mozna napisac
                 ;to tak: eax=eax*esi*64...chyba juz kumasz?:)))

chyba teraz lepiej to wyglada?...jasne. Kiedy juz przejdziemy przez ta procke otrzymamy liczbe (dla naszych danych):35538464h
Lecimy dalej...:

017F:0045D462    LEA       EDX,[EBP-0100]
017F:0045D468    MOV       EAX,[00463A20] <<tu
017F:0045D46D    CALL      00402A80       ;hmm...
017F:0045D472    LEA       EDX,[EBP-0100]
017F:0045D478    MOV       EAX,00463A24

popatrz na linie, ktora ci zaznaczylem...do eax jest wpisywana wartosc, ktora zostala obliczona z drugiej czesci kodu...a potem mamy CALL-a. Zobaczmy co w nim jest:

017F:00402A80   MOV       ECX,EDX
017F:00402A82   XOR       EDX,EDX
017F:00402A84   JMP       00402A20   <<ciekawy skok
017F:00402A89   RET

proponuje zobaczyc gdzie przeniesie nas ten skok:

017F:00402A30   MOV       ECX,0000000A
017F:00402A35   XOR       EBX,EBX
017F:00402A37   XOR       EDX,EDX
017F:00402A39   DIV       ECX
017F:00402A3B   ADD       EDX,30
017F:00402A3E   MOV       [EBX+ESP],DL
017F:00402A41   INC       EBX
017F:00402A42   TEST      EAX,EAX
017F:00402A44   JNZ       00402A37

...co sie tu robi?...huh...mysl...pamietaj, ze w eax jest nasza liczba ...podpowiadam...ale ja jestem dobry dla was;)) Zacznijmy od podstaw...jak dziala polecenie div??...div sluzy do dzielenia, przy czym dzielna znajduje sie w eax, a dzielnik w rejestrze. Po wykonaniu dzielenia, 
wynik jest zapisywany do eax, a reszta z dzielenia do edx. Teraz popatrz na nasza procke...chyba juz widzisz, ze nasza obliczona liczba jest dzielona przez 0ah, a nastepnie do reszty z dzielenia jest dodawana liczba 30h...po co?...zeby zamienic ja na postac ASCII, czyli znaku, ktory mozna spokojnie wyrzucic na ekran. Widac, ze cyferki kodu beda powstawaly, dopoki eax bedzie rowne zero. Procka wygenerowala numerek:
828566498
Dalej mamy to:

017F:00402A46   TEST      ESI,ESI
017F:00402A48   JGE       00402A4F
017F:00402A4A   MOV       BYTE PTR [EBX+ESP],2D

..huh...znow troche mieszania...powiem o co tu chodzi, a jesli bedziesz chcial, to sam sie pomeczysz i dojdziesz dlaczego tak;)...ten kawalek kodu sprawdza czy dopisac znak "-" na koncu naszego wygenerowanego kodu ...w naszym przypadku nie trzeba. ...idziemy dalej:

017F:00402A6E   MOV       AL,[EBX+ESP-01] (1)
017F:00402A72   MOV       [EDI],AL        (2)
017F:00402A74   INC       EDI             (3)
017F:00402A75   DEC       EBX             (4)
017F:00402A76   JNZ       00402A6E        (5)

Procka dziala tak: bierze ostatni znak z wygenerowanego kodu (1) i kopiuje go pod jakis adres w pamieci, nastepnie adres w pamieci jest powiekszany o 1, a wskaznik do naszego haselka przesuwa sie o jeden znak do tylu...i znow kopiowanie znaku...co to oznacza?...po prostu procka obraca nasz numerek...zapisuje go od konca...huh..chyba czaisz co i jak;) Czyli teraz mamy numerek: 894665828
Kawalek dalej (F10) mamy to:

017F:0045D488    MOV       ECX,0045D690   ;tu adres do ciagu "KAMI"
017F:0045D48D    MOV       EDX,[00463A24] ;tu adres do naszego numerka
017F:0045D493    CALL      00403CA8       ;???
017F:0045D498    MOV       EAX,[EBP-0104] ;w eax mamy masz numerek+KAMI
017F:0045D49E    MOV       EDX,[00463834] ;numerek w pliku
017F:0045D4A4    CALL      00403D6C       ;sprawdzenie poprawnosci
017F:0045D4A9    JZ        0045D4DD       ;skok bad/good

...zobaczymy czy wyczaisz teraz co i jak;)...jak myslisz, co jest robione w CALL-u, ktory oznaczylem "???" ??...widac, ze po prostu sluzy on do tego, aby dopisac do konca naszego wygenerowanego numerku staly ciag liter "KAMI"...idz do linii 0045D498 i zobacz co jest w eax:

d eax

...mamy tam poprawny numerek, czyli 894665828KAMI
Poprawmy wiec nasz plik...i co sie teraz stalo...hmm...dziala...Matrix sie zarejestrowal, ale patrz na name:PSRUTWVY...hmm...czyli dalej cos nie tak...idziemy dalej w kodzie...dochodzimy do takiego miejsca:

017F:0045D50C   MOV       AL,[EDX+EAX-01]
017F:0045D510   XOR       AL,0D
017F:0045D512   MOV       [EDI],AL
017F:0045D514   MOV       AL,[EDI]
017F:0045D516   XOR       AL,14
017F:0045D518   MOV       [EDI],AL
017F:0045D51A   MOV       AL,[EDI]
017F:0045D51C   XOR       AL,24
017F:0045D51E   MOV       [EDI],AL
017F:0045D520   MOV       AL,[EDI]
017F:0045D522   XOR       AL,0C
017F:0045D524   MOV       [EDI],AL
017F:0045D526   LEA       EAX,[EBP-0108]         ;
017F:0045D52C   MOV       DL,[EDI]               ;
017F:0045D52E   CALL      00403B84               ;to jest po to,aby
017F:0045D533   MOV       EDX,[EBP-0108]         ;petla sie krecila i
017F:0045D539   MOV       EAX,00463834           ;zeby zapisac wynik
017F:0045D53E   CALL      00403C64               ;do pamieci;)))
017F:0045D543   INC       DWORD PTR [00463848]   ;
017F:0045D549   DEC       EBX                    ;
017F:0045D54A   JNZ       0045D501               ;

Procka dziala tak...do al wrzuca pierwsza litere z pliku po "0dh" i wykonuje na niej operacje matematyczne, potem bierze nastepna i znow to samo..itd...popatrz dokladnie co sie dzieje w tej petelce...jesli sie dobrze przyjrzysz, to zobaczysz, ze przksztalca ona nasz ciag:
abcdefgh na PSRUTWVY...czyli po prostu tworzy name do pola w Matrixie z danych w pliku...to co teraz trzeba zrobic, zeby miec tam swoje imie? ...zacznijmy od przeksztalcenia procki:

mov al,[edx+eax-01]
xor al,0dh
xor al,14h
xor al,24h
xor al,0ch

...chce uzyskac napis: Sawka is OK (pamietaj!!!...wiecej niz 5 liter) ...czyli musze po prostu odwrocic cala ta procke i wstawic za al kolejne znaki...odwracamy:

mov al,[edx+eax-01]
xor al,0ch
xor al,24h
xor al,14h
xor al,0dh

...to liczymy w SI:

:?'S'^0c
0000005F  0000000095  "_"
:?5f^24
0000007B  0000000123  "{"
:?7b^14
0000006F  0000000111  "o"
:?6f^0d
00000062  0000000098  "b"
...wyszlo nam,ze pierwszy znak to bedzie "b"...teraz trzeba tak policzyc reszte znakow...
i...wkurzysz sie teraz...trzeba na nowo wklepac dane do pliku i wygenerowac numerek dla nich...milej roboty, ja spadam;) KeyGen jest dolaczony do tutorka...generuje keyfile dla 
dowolnego name.

7.Poziom 5

Nastepny poziom jest chyba dla odprezenia:)))...zwykle code...i do tego podobno harder...juz sie boje;)) Znalezienie tego kodu powinno ci zajac plus/minus 5 sekund:)))))) Zaczynamy...wklepujemy dane:

code: 1234567890

teraz zastawiamy pulapke na kopiowanie danych z pamieci:

bpx hmemcpy

...naciskamy OK i znow w SI...teraz kilka razy F12 zeby sie dostac do kodu Matrix-a i widzidzmy takie cos:

017F:0045FC72    MOV       EAX,[EBP-04] ;nasz serial
017F:0045FC75    MOV       EDX,0045FD60 ;poprawny serial
017F:0045FC7A    CALL      00403D6C     ;sprawdzanie poprawnosci
017F:0045FC7F    JZ        0045FCB3     ;skok bad/good
017F:0045FC81    MOV       EDX,0045FD78
017F:0045FC86    MOV       EAX,[EBX+000002D8]
017F:0045FC8C    CALL      004265E0

...zeby uzyskac kod trzeba wiec dac:

d edx

i...po wszystkim...WOW!...oops...wygadalbym sie;)))

8.Poziom 6

Przyznaje sie,ze nie mam pojecia jak ugryzc to cholerstwo:((((

9.Poziom 7

Nastepny poziom, to znow KeyFile...ale tym razem "harder";)...w sumie harder, to tylko sie on nazywa:)..autor tylko pozmienial troche procki, powinienies sam sprobowac rozwalic ten pozoim...latwizna. Mamy jednak w nim troche walkow...po pierwsze uruchom sobie Frogice, bo Matrix
moze cie troche zamieszac;) Po drugie Matrix otwiera sobie rozne pliki i trzeba wybrac wlasciwe:)
Zaczyna sie od pliku Key.dat...to nie jest wlasciwy plik...ale spojrzmy do SI :

017F:004054FB     PUSH      00
017F:004054FD     PUSH      00000080
017F:00405502     PUSH      ECX
017F:00405503     PUSH      00
017F:00405505     PUSH      EDX
017F:00405506     PUSH      EAX
017F:00405507     LEA       EAX,[ESI+48]
017F:0040550A     PUSH      EAX               ;Key.dat
017F:0040550B     CALL      KERNEL32!CreateFileA
017F:00405510     CMP       EAX,-01
017F:00405513     JZ        00405604   ;ten skok musi sie wykonac!

Jesli mi nie wierzysz, ze ten plik to zmyla, to pobaw sie sam;) Dalej Matrix chce otworzyc plik sabrina.dat i to jest poprawny plik:

017F:004054FB     PUSH      00
017F:004054FD     PUSH      00000080
017F:00405502     PUSH      ECX
017F:00405503     PUSH      00
017F:00405505     PUSH      EDX
017F:00405506     PUSH      EAX
017F:00405507     LEA       EAX,[ESI+48]
017F:0040550A     PUSH      EAX              ;sabrina.dat
017F:0040550B     CALL      KERNEL32!CreateFileA
017F:00405510     CMP       EAX,-01
017F:00405513     JZ        00405604          ;skocz!
               
Dalej identycznie jak w poprzednim KeyFile...zmienila sie tylko procka obliczajaca liczbe na podstawie name, wyglada teraz tak:

017F:0045F91C   MOV       DWORD PTR [00463848],00000001
017F:0045F926   MOV       EAX,[00463838]
017F:0045F92B   MOV       EDX,[00463848]
017F:0045F931   MOVZX     EAX,BYTE PTR [EDX+EAX-01]
017F:0045F936   ADD       [00463A20],EAX
017F:0045F93C   XOR       DWORD PTR [00463A20],20
017F:0045F943   ADD       DWORD PTR [00463A20],000000FE
017F:0045F94D   SHR       DWORD PTR [00463A20],1
017F:0045F953   IMUL      EAX,[00463A20],00000096
017F:0045F95D   MOV       [00463A20],EAX
017F:0045F962   INC       DWORD PTR [00463848]
017F:0045F968   DEC       EBX
017F:0045F969   JNZ       0045F926

..huh...co tu jeszcze sie zmienilo...aha procka odkodowywania name jest teraz taka:

017F:0045FA0A   MOV       DWORD PTR [00463848],00000001
017F:0045FA14   MOV       EAX,[00463838]
017F:0045FA19   MOV       EDX,[00463848]
017F:0045FA1F   MOV       AL,[EDX+EAX-01]
017F:0045FA23   XOR       AL,0F
017F:0045FA25   MOV       [EDI],AL
017F:0045FA27   MOV       AL,[EDI]
017F:0045FA29   XOR       AL,0E
017F:0045FA2B   MOV       [EDI],AL
017F:0045FA2D   MOV       AL,[EDI]
017F:0045FA2F   XOR       AL,22
017F:0045FA31   MOV       [EDI],AL
017F:0045FA33   MOV       AL,[EDI]
017F:0045FA35   XOR       AL,0B
017F:0045FA37   MOV       [EDI],AL
017F:0045FA39   LEA       EAX,[EBP-0108]
017F:0045FA3F   MOV       DL,[EDI]
017F:0045FA41   CALL      00403B84
017F:0045FA46   MOV       EDX,[EBP-0108]
017F:0045FA4C   MOV       EAX,00463834
017F:0045FA51   CALL      00403C64
017F:0045FA56   INC       DWORD PTR [00463848]
017F:0045FA5C   DEC       EBX
017F:0045FA5D   JNZ       0045FA14

odwrocic to juz chyba potrafisz...:)...na wszelki wypadek:

mov al,znak
xor al,0bh
xor al,22h
xor al,0eh
xor al,0fh

...co tu jeszcze sie pozmienialo...:))))...ahja...tamtym razem progi dopisywal do koncowki pierwszej czesci haselka ciag "KAMI"...teraz dopisuje takie cos...schemacik: MONIKA(-)numerekKAMI*0dh*name*1ah*
                                ^^^^^^ ^        ^^^^
                                       |
                                  ewentualnie

..to to na tyle,zycze milej zabawy z tym poziomem:)...licze na ciebie..pamietaj - wszystko robi sie analogicznie jak w trzecim poziomie.

10.Poziom 7

Witaj na siodmym poziomie...teraz mamy cos ciekawego...CheckBox:)) To zaczynamy!!! Wklepujemy jeskies dane(dluzsze niz 4 znakow)

name: Sawka is OK

i zaznaczamy kilka losowych checkbox-ow.Teraz zakladamy plupake :

bpx hmemcpy

i naciskamy OK. Jestesmy znow w SI...teraz naciskamy F12 az do takiego miejsca:

017F:0045EDB5   MOV       EDX,[EBP-04]
017F:0045EDB8   MOV       EAX,0046383C
017F:0045EDBD   CALL      00403A30
017F:0045EDC2   MOV       EAX,[0046383C]
017F:0045EDC7   CALL      00403C5C          ;do eax dlugosc name
017F:0045EDCC   CMP       EAX,04            ;jesli krotsze niz piec to
017F:0045EDCF   JG        0045EE03          ;zle...:(

...dalej mamy to:

017F:0045EE17  MOV       EDX,[0046383C]           ;offset do name
017F:0045EE1D  MOV       ECX,[ESI]                ;do petli
017F:0045EE1F  MOVZX     EDX,BYTE PTR [ECX+EDX-01];do edx pierszy znak
017F:0045EE24  ADD       [EDI],EDX              ;dodaje [edi]=[edi]+edx
017F:0045EE26  INC       DWORD PTR [ESI]          ;
017F:0045EE28  DEC       EAX                      ;
017F:0045EE29  JNZ       0045EE17                 ;i skacze az skonczy

...co tu sie robi??...procka po prostu sumuje wartosci hex kolejnych liter z naszego name. Dla moich danych wyszlo: 03ADh.Mozesz to sprawdzic za pomoca :

d edi

...i dalej:

017F:0045EE2B   MOV       EAX,[EDI]   ;w eax jest suma znakow
017F:0045EE2D   SAR       EAX,1       ;przesuniecie w prawo o 1
017F:0045EE2F   JNS       0045EE34    ;lepiej zeby tu skoczyl:)
017F:0045EE31   ADC       EAX,00      ;...;)
017F:0045EE34   MOV       [EDI],EAX   ;i do [edi] wraca liczba

Ta procka po prostu przerabia troche nasza liczbe(troche ja zmniejsza). Mi wyszlo:1D6h. Dochodzimy teraz do sedna tego poziomu:

017F:0045EE5D   CALL      [EDX+000000B4]      <<
017F:0045EE63   CMP       AL,01
017F:0045EE65   JNZ       0045EE68
017F:0045EE67   INC       ESI                 +
017F:0045EE68   MOV       EAX,[EBX+0000031C]
017F:0045EE6E   MOV       EDX,[EAX]
017F:0045EE70   CALL      [EDX+000000B4]      <<
017F:0045EE76   CMP       AL,01
017F:0045EE78   JNZ       0045EE7D
017F:0045EE7A   ADD       ESI,02              +
017F:0045EE7D   MOV       EAX,[EBX+00000320]
017F:0045EE83   MOV       EDX,[EAX]
017F:0045EE85   CALL      [EDX+000000B4]      <<
017F:0045EE8B   CMP       AL,01
017F:0045EE8D   JNZ       0045EE92
017F:0045EE8F   ADD       ESI,03              +
017F:0045EE92   MOV       EAX,[EBX+00000324]
017F:0045EE98   MOV       EDX,[EAX]
017F:0045EE9A   CALL      [EDX+000000B4]      <<
017F:0045EEA0   CMP       AL,01
017F:0045EEA2   JNZ       0045EEA7
017F:0045EEA4   ADD       ESI,04              +
...
017F:0045F15F   CMP       ESI,[EDI]      ;porownanie
017F:0045F161   JNZ       0045F19A       ;skok bad/good
kodu jest bardzo duuuzo...to tylko wycinek...co robia oznaczone procki? ...sprawdzaja one ktore checkbox-y sa zaznaczone...jesli checkbox jest zaznaczony, to procka zwraca 1 w al. Spojrz teraz na rejestr esi...co sie z nim robi?...cos sie do niego caly czas dodaje (oznaczone +)...po co?... ja to widze tak, ze jesli box jest zaznaczony,to do esi dodawana jest wartosc jaka jest do tego boxa przyporzadkowana...i na koncu widac, ze liczba jaka wyjdzie jest porownywana z nasza liczba, ktora powstala na podstawie name...chyba nadazasz:))...po prostu musimy na koncu otrzymac wynik jaki wyszedl nam z name. Przydaloby sie spisac sobie jakie wartosci odpowiadaja jakim boxom...dla leniwych(od lewego gornego rogu):

1h,2h,3h,4h,5h,6h,7h,8h,9h,0Ah,14h,1Eh,28h,32h,3Ch,46h,50h,5Ah,64h,C8h,12Ch,
190h,1F4h,258h,2BCh,320h,384h,0Bh,16h,21h,2Ch,37h,42h,4Dh,58h,63h

przypominam, ze ja musze otrzymac liczbe 1D6h...czyli dla moich danych musze np. zaznaczyc boxy:46h+190h (nr.16 i 22)...i po sprawie:)) KeyGen z wyjasnieniami jak zwykle z tekstem.

11.Poziom 8

Huh...teraz troche luzu:)) ...do zalatwienia mamy naga;)...to raz..:)) Popatrz na naga...chyba
widzisz, ze jest to zwykle okenko z jakims tam obrazkiem w srodku. Musimy jakos przerwac Matrix-a kiedy bedzie tworzyl te okno...hmmm...jakiej funkji uzywa sie jesli chcemy pokazac okno na ekranie???...pewnie!!!... ShowWindow...to zakladamy pulapke...:

bpx showwindow

uruchamiamy znow poziom z nagiem i jestesmy znowu w SI...teraz troche klepania w F10, az dojdziemy tu:

017F:0045E18B   CALL      004410D8               ;stad wyszlismy
017F:0045E190   CMP       BYTE PTR [00463A2C],01 ;
017F:0045E197   JNZ       0045E1BB               ;...a kogo to obchodzi
017F:0045E199   XOR       EDX,EDX                ;co tu jest robione;)
017F:0045E19B   MOV       EAX,[ESI+000003C4]     ;
017F:0045E1A1   MOV       ECX,[EAX]              ;

..czyli w CALL 004410D8 jest tworzone okienko z nagiem...jak to obejsc? ...proponuje na poczatku tego CALL-a wstawic wartosc 0C3h-czyli "ret" ...w ten sposob nic nie powstanie:) Nasz CALL zaczyna sie pod adresem 004410D8, a to jest offset 404D8h.W Hiew wpisujemy tam wartosc C3 i 
naga nie ma:))) Patch jest standardowo dolaczony do tekstu:))

12.Poziom 9

Nastepne zabezpieczenie to Id/code...czyli kod generowany na podstawie numerku, ktory jest inny za kazdym razem. Wklepujemy jakis numerek i zastawiamy pulapke:

bpx hmemcpy

naciskamy na OK i znow w SI....teraz kilka razy F12 i jestesmy gdzie trzeba:

017F:0045D9AD   MOV       EAX,[EBP-2C]    ;nasz numer
017F:0045D9B0   MOV       EDX,[EDI]       ;poprawny numerek
017F:0045D9B2   CALL      00403D6C        ;sprawdzanie poprawnosci
017F:0045D9B7   JNZ       0045D9F6        ;skok good/bad  ..jesli
                                          ;chcemy poprawny numer:

d edx

i po sprawie:)))))...czas 5 sekund:)))
Teraz mamy napisac KeyGena...so potrzebujemy dowiedziec sie jak progi generuje nasz kod. Sprawdzmy co jest wyzej w oknie kodu...czyli Ctrl+strzalka gora i mamy takie cos:

017F:0045D8A9   MOV       EAX,[00463850]                (1)
017F:0045D8AE   MOV       EDX,[ESI]                     (2)
017F:0045D8B0   MOV       AL,[EDX+EAX-01]               (3)
017F:0045D8B4   XOR       AL,0C                         (4)
017F:0045D8B6   MOV       [EBX],AL                      (5)
017F:0045D8B8   MOV       AL,[ESI]                      (6)
017F:0045D8BA   XOR       [EBX],AL                      (7)
017F:0045D8BC   ADD       BYTE PTR [EBX],16             (8)
017F:0045D8BF   SUB       BYTE PTR [EBX],15             (9)
017F:0045D8C2   MOV       AL,[EBX]                      (10)
017F:0045D8C4   XOR       AL,0F                         (11)
017F:0045D8C6   MOV       [EBX],AL                      (12)
017F:0045D8C8   ADD       BYTE PTR [EBX],1E             (13)
017F:0045D8CB   MOV       AL,[EBX]                      (14)
017F:0045D8CD   CMP       AL,41                         (15)
017F:0045D8CF   JAE       0045D8D4                      (16)
017F:0045D8D1   ADD       BYTE PTR [EBX],1E             (17)
017F:0045D8D4   MOV       AL,[EBX]                      (18)
017F:0045D8D6   CMP       AL,5A                         (19)
017F:0045D8D8   JBE       0045D8DD                      (20)
017F:0045D8DA   SUB       BYTE PTR [EBX],14             (21)
017F:0045D8DD   LEA       EAX,[EBP-08]                  ;
017F:0045D8E0   MOV       DL,[EBX]                      ;
017F:0045D8E2   CALL      00403B84                      ;
017F:0045D8E7   MOV       EDX,[EBP-08]                  ;
017F:0045D8EA   MOV       EAX,EDI                       ;
017F:0045D8EC   CALL      00403C64                      ;
017F:0045D8F1   INC       DWORD PTR [ESI]               (22)
017F:0045D8F3   CMP       DWORD PTR [ESI],07            (23)
017F:0045D8F6   JNZ       0045D8A9                      (24)

oki...przeanalizujmy to powoli.W linijce (1) do eax jest wrzucany offset do czesci cyfrowej id bez znakow "-"...heh...moze pokaze na przykladzie. Jesli progi wygenerowl sobie numerek: EM-14-84-95, to w eax bedzie offset do ciagu "148495"...kumasz?...no to spoko. W linii (2) 
do edx jest wpisywana wartosc licznika petli (za pierwszym razem 1, za drugim 2..itd). W linii (3) do al wpisywana jest pierwsza cyfra z naszego ciagu. W linii (4) wartosc hex tej liczby jest xorowana z wartoscia 0ch. W linii (5) wynik z tej operacji jest wpisaywany pod jakis adres w pamieci. W (6) do al jest wpisywana wartosc licznika spod adresu w esi. Teraz nasza liczba jest xorowana z wartoscia licznika(7). W linii (8) do naszego wyniku jest dodawana 16h, a nastepnie w linii (9) jest od niego odejmowana wartosc 15h. Linie od (10) do (21) maja za zadanie poprzeksztalcac troche nasz numerek. Linie (22) do (24) potrzebnie sa dla petli. Ok...czyli wiemy juz jak jest generowany poczatek kodu (do znaku "-"), ale co dalej?...jesli poklepiesz troche
w F8 i wejdziesz gleboko w pare CALL-ow, to dojdziesz do takich wnioskow jak ja...moze pokaze na przykladzie:

QWERTY-RWTEYQ-XX    ;XX - pierwsze dwie litery ID
123456 425361

Jak widzisz, caly myk polega jedynie na przestawianu literek. Prosciutko juz napisac KeyGena.
Popatrz - powinien byc z tekstem.

13.Poziom 10

Czas na ostatni poziom...czyli Your PC code...czyli kod, ktory jest rozny na kazdym komputerze. Chyba wiesz co robic...wklepujemy numerek i zastawiamy pulapke:

bpx hmemcpy

dajemy OK i jestesmy w SI. Teraz pare razy F12 i jestesmy tu:

017F:0045E942   MOV       EAX,[EBP-20]   ;nasz numer
017F:0045E945   MOV       EDX,[ESI]      ;poprawny numerek
017F:0045E947   CALL      00403D6C       ;sprawdzenie
017F:0045E94C   JNZ       0045E98B       ;skok bad/good

...hmm...procka identyczna jak poprzednio:))...czas 5 sekund;) To jeszcze jednak nie koniec...musimy zrobic KeyGena!! Musimy dojsc do tego, jak i na podstawie czego progi generuje poprawny numer. Na pewno musi bazowac na jakiejs stalej wartosci dla danego kompa, skoro numer 
jest inny na kazdym komputerku. Co jest stale w kazdym kompie??...kurde masa takich rzeczy jest...moze progi szuka czegos w rejestrze...sprawdzmy. Wchodzimy do Regmona, ustawiamy filtr na "matrix" i powtarzamy czynnosci w Matrixie,czyli wklepujemy dane i naciskamy OK...sprawdzmy 
co tam nam wyszlo w RegMonie:

Matrix  OpenKey  HKLM\Software\Microsoft\Windows\CurrentVersion SUCCESS
Matrix  QueryValueEx    HKLM\Software\...\ProductKey    SUCCESS
Matrix  QueryValueEx    HKLM\Software\...\ProductKey  SUCCESS
Matrix  QueryValueEx    HKLM\Software\...\ProductKey  SUCCESS
                              "VDHYY-PGF4C-8MWRM-D3QGG-TCYRG"

...o juz ciekawiej...Matrix najwyrazniej generuje kod na podstawie numerku z Windowsa:)))...sprawdzmy!! Zastawiamy pulapke na :

bpx RegQueryValueExA

wklepujemy dane i dajemy OK...

017F:00448A2A   CALL      ADVAPI32!RegQueryValueExA ;otwieranie klucza
017F:00448A2F   TEST      EAX,EAX                   ;tu wyladowalismy
017F:00448A31   SETZ      BL
017F:00448A34   MOV       EAX,[ESP]
017F:00448A37   CALL      004487A8
017F:00448A3C   MOV       [EBP+00],AL
017F:00448A3F   MOV       EAX,EBX
017F:00448A41   POP       EDX
017F:00448A42   POP       EBP
017F:00448A43   POP       EDI
017F:00448A44   POP       ESI
017F:00448A45   POP       EBX
017F:00448A46   RET

...teraz wylaczamy pulapke:

bd *

i klepiemy w F10,az do takiego momentu:

017F:0045E848   MOV       EAX,[00463834]   ;offset do seriala windy
017F:0045E84D   MOV       EDX,[EBX]        ;do petli
017F:0045E84F   MOV       AL,[EDX+EAX-01]  ;do al pierwszy znak seriala
017F:0045E853   ADD       AL,03            ;dodaj do niego 3h
017F:0045E855   MOV       [EDI],AL         ;i zapisz gdzies w pamieci
017F:0045E857   LEA       EAX,[EBP-10]
017F:0045E85A   MOV       DL,[EDI]
017F:0045E85C   CALL      00403B84
017F:0045E861   MOV       EDX,[EBP-10]
017F:0045E864   MOV       EAX,ESI
017F:0045E866   CALL      00403C64
017F:0045E86B   INC       DWORD PTR [EBX]
017F:0045E86D   CMP       DWORD PTR [EBX],06  ;powtarzaj az dojdziesz
017F:0045E870   JNZ       0045E848           ;do znaku "-"...obrazowo;)

Mamy juz poczatek, czyli pierwsza czesc naszgo kodu jest generowana po prostu poprzez dodawanie wartosci 03h do naszych liter w serialku windowsa. Nastepne czesci sa podobne:

017F:0045E889  MOV       EDX,[00463834]       ;offset do seriala po "-"
017F:0045E88F  MOV       AL,[EAX+EDX-01]      ;do al pierwszy znak
017F:0045E893  SUB       AL,03                ;tu z kolei odejmowanie
017F:0045E895  MOV       [EDI],AL
017F:0045E897  LEA       EAX,[EBP-14]
017F:0045E89A  MOV       DL,[EDI]
017F:0045E89C  CALL      00403B84
017F:0045E8A1  MOV       EDX,[EBP-14]
017F:0045E8A4  MOV       EAX,ESI
017F:0045E8A6  CALL      00403C64
017F:0045E8AB  INC       DWORD PTR [EBX]
017F:0045E8AD  CMP       DWORD PTR [EBX],06
017F:0045E8B0  JNZ       0045E884

Druga czesc to z kolei odejmowanie od literek seriala wartosci 03h. I dalej:

017F:0045E8C9  MOV       EDX,[00463834]    ;offset do 3 cz. seriala win
017F:0045E8CF  MOV       AL,[EAX+EDX-01]   ;do al pierwszy znak
017F:0045E8D3  DEC       EAX               ;od al odejmij jeden
017F:0045E8D4  MOV       [EDI],AL
017F:0045E8D6  LEA       EAX,[EBP-18]
017F:0045E8D9  MOV       DL,[EDI]
017F:0045E8DB  CALL      00403B84
017F:0045E8E0  MOV       EDX,[EBP-18]
017F:0045E8E3  MOV       EAX,ESI
017F:0045E8E5  CALL      00403C64
017F:0045E8EA  INC       DWORD PTR [EBX]
017F:0045E8EC  CMP       DWORD PTR [EBX],06
017F:0045E8EF  JNZ       0045E8C4

Trzecia czesc to znow odejmowanie, ale tym razem odejmujemy wartosc 01h. I ostatnia czesc kodu:

017F:0045E908   MOV       EDX,[00463834]   ;offset do 3 cz. seriala win
017F:0045E90E   MOV       AL,[EAX+EDX-01]  ;do al pierwszy znak
017F:0045E912   SUB       AL,02            ;odejmij od al 02h
017F:0045E914   MOV       [EDI],AL
017F:0045E916   LEA       EAX,[EBP-1C]
017F:0045E919   MOV       DL,[EDI]
017F:0045E91B   CALL      00403B84
017F:0045E920   MOV       EDX,[EBP-1C]
017F:0045E923   MOV       EAX,ESI
017F:0045E925   CALL      00403C64
017F:0045E92A   INC       DWORD PTR [EBX]
017F:0045E92C   CMP       DWORD PTR [EBX],06
017F:0045E92F   JNZ       0045E903

heh...i znow odejmowanie...tym razem wartosc 02h. I to wszystko!!!:)) ...mamy caly numerek...mozna juz spoko pisac keygena...looknij-powinien byc z tekstem. Heh...jedno mnie meczy...kto powiedzial, ze ten kod bedzie rozny na innych komputerach:))))...wiadomo jak jest;))) 

14.Ending;)

Noi Crackme rozwalone w 90%:((...poziom 6 przeros mnie nieco. Nic jednak nie stoi na przeszkodzie, zeby pojsc na zasluzonego browca:))))