

Windows Cracking Tutorial v1.o                                   Strona  1 z 7
ED!SON's Windows 95 Cracking Tutorial v1.oo
Na podstawie orginalnego tekstu ED!SON'a
przetlumaczyl na jezyk polski WARP.
===========================================

SPIS TRESCI
========
1.  Wstep do crackingu w Windows
2.  Krotkie wprowadzenie do SoftICE/Win 2.oo
3.  Szukanie kodu rejestracyjnego
3.1  Task Lock 3.00 - Proste zabezpieczenie numeru rejestracyjnego
3.2  Command Line 95 - Prosta rejestracja nazwy/numeru
4.  Tworzenie generatora numerow dla Command Line 95
5.  Wykorzystywanie PUSH i CALL
6.  O programach napisanych w Visual Basic

DODATEK
========
A.  Ladowanie symboli w SOFTICE
B.  Skladnia funkcji
C.  Gdzie uzyskac oprogramowanie
D.  Kontakt ze mna
E.  Uwagi od tlumacza


1. WPROWADZENIE DO CRACKINGU W WINDOWS
======================================
Cracking  programow  dla  Windows  jest czesto znacznie prostszy niz programow
DOS.  W Windows trudno jest cokolwiek ukryc przed kims, kto rzeczywiscie szuka
informacji,  a  ta  sytuacja  bedzie  trwala  tak  dlugo,  jak  Windows bedzie
uzywal funkcji.

Najpierw  (i  czesto  tylko)  bedziesz  potrzebowal programu SoftICE/Win 2.oo,
swietnego  debuggera  od  firmy NuMega. Wielu ludzi nie radzi sobie z nim, ale
ja  ci  powiem  jak  efektywnie  korzystac  z tego swietnego narzedzia , i mam
nadzieje, ze mnie zrozumiesz :-)
Napisalem  Dodatek  (A)  z  informacjami  na  temat  SoftICE/Win  2.oo,  ktore
powiniennes przeczytac.
Nigdy  nie  mialem  problemow  z  zainstalowaniem SoftICE, wiec jesli bedziesz
takowe posiadal, zajrzyj do podrecznika (lub pomocy).

Adresy,  skad  mozesz  sciagnac  cale  potrzebne  oprogramowanie  podane  sa w
Dodatku C.

- ED!SON, edison@ccnux.utm.my


2. KROTKIE WPROWADZENIE DO SOFTICE/WIN 2.OO
===========================================
Prawdopodobnie bedzie ci trudno zrozumiec rozmieszczenie elementow SoftICE:

|--------------------|
|     Rejestry       |  Uzyj 'R' zeby edytowac
|--------------------|
|    Okno Danych     |  Uzyj 'D' zeby zobaczyc adres, 'E' zeby edytowac
|--------------------|
|     Okno Kodu      |  Uzyj 'U' zeby zobaczyc adres, 'A' zeby wstawic kod asm
|--------------------|
|    Okno Polecen    |  Wpisz polecenie, lub czytaj jego wynik
|--------------------|

Inne wazne klawsze (przy domyslnych ustawieniach) :
'H'/F1   - Pomoc
F5/Ctr+D - Uruchom/wywolaj
F8       - Krok do funkcji
F10      - Krok przez funkcje
F11      - Krok do nastepnej funkcji


3. SZUKANIE KODU REJESTRACYJNEGO
================================
Prawdopodobnie   prostsza   droga  to  praktyka,  dlatego  wez  jakis  program
shareware i sprobuj go zarejestrowac.

3.1 Task Lock 3.00 - Proste zabezpieczenie numeru rejestracyjnego
=================================================================
Jest to proste zabezpieczenie - kod, ktory w dodatku sie nie zmienia.

3.1.1 Badanie programu
======================
Czy  jest  16  czy 32 bitowy? Gdzie wpisac informacje rejestracyjne? Czy pomoc
da  mi  jakies  wskazowki  pomogace  mi  go  zarejestrowac ? Dowiedz sie zanim
zaczniesz czytac dalej !
....Powiniennes sprawdzic teraz!...Robisz to?...Sprawdziles?...
OK,  teraz  juz  wiesz,  ze  jest  to  32 bitowa aplikacja Windows 95 i mozesz
zarejestrowac  program wpisujac Numer Rejestracyjny w okienu dialogowym, ktore
wyswietli  sie jesli wybierzesz w menu "Register|Register...". Wiesz takze, po
przeczytaniu  pomocy, ze sa dwa typy rejestracji: Indywidualna i Grupowa. Wiec
bardzo mozliwe, ze program DWA razy sprawdza poprawnosc wprowadzonego numeru.


3.1.2 Pulapki na procedury
==========================
Kod  jest zazwyczaj wprowadzany w normalnym oknie Windows Edit. Zeby sprawdzic
kod, program musi odczytac zawartosc okna Edit, przez jedna z tych funkcji:

        16-bitowe                   32-bitowe
        ---------                   ---------
        GetWindowText               GetWindowTextA, GetWindowTextW
        GetDlgItemText              GetDlgItemTextA, GetDlgItemTextW

Ostatnia   litera   32-bitowych   funkcji   mowi   nam,   czy   funkcja  uzywa
jedno-bajtowego, czy dwu-bajtowego ciagu znakow. Dwu-bajtowy kod jest RARE.
Byc  moze  zrozumiales  moj  cel...  "Gdyby  tylko  umiec  postawic pulapke na
GetWindowText"  I  ty  to  potrafisz!  Ale  najpierw  musisz byc pewien, ze te
symbole, zostaly zaladowane przez SoftICE. (Zobacz Dodatek A)

Zeby  ustawic  "pulapke"  (nazywana  breakpoint)  w  SoftICE, musisz uruchomic
debugger  klawiszami  Ctrl+D,  a  nastepnie  uzyc  polecenia BPX razem z nazwa
funkcji  lub  adresem  pamieci.  Poniewaz  Task Lock jest 32-bitowy, sprobujmy
ustawic  pulapke  na GetWindowTextA. Jesli nie bedzie dzialac, sprobujemy inna
funkcje.

Wpisz tak do SoftICE:
        :bpx getwindowtexta

Jesli  dostaniesz  komunikat  bledu  wygladajacy tak "No LDT", upewnij sie, ze
nie  dziala  zadna  inna  aplikacja w tle. Zauwazylem, ze Norton Commander/Dos
zaklocaja  te funkcje. Mozesz sprawdzic, czy sa zalozone inne pulapki wpisujac
polecenie:

        :bl

Powiniennes zobaczyc cos w tym stylu:
        00)   BPX USER32!GetWindowTextA C=01

Zeby opuscic SoftICE, nacisnij ponownie Ctrl+D

Dobra, w kazdym razie ustawiles pulapke, ktora wychwyci kazde odwolanie do
GetWindowTextA.  Teraz  sprobuj  wpisac  jakas wartosc w polu rejestracyjnym i
wcisnij  OK...  Nacisnales  OK... i dostales tylko glupi komunikat mowiacy, ze
wprowadzony kod jest zly. Wiec nie jest to GetWindowTextA... Sprobujmy
GetDlgItemTextA. Najpierw usunmy poprzednia pulapke:
        :bc 0
(0 oznacza numer pulapki w liscie pulapek)

Teraz ustawmy nowa:
        :bpx getdlgitemtexta

Sprobujmy jeszcze raz...


3.1.3 W debuggerze
==================
Wow!   To  dziala!  W tej chwili jestes w SoftICE, w miejscu, gdzie rozpoczela
sie  funkcja  GetDlgItemTextA.  Aby skoczyc gdziekolwiek skad zostala wywolana
nacisnij  klawisz  F11.  Jestes  teraz  wewnatrz  SGLSET.EXE, jesli nie jestes
pewien,  spojrz  na  linie  miedzy  kodem a oknem polecen, powinno to wygladac
mniej wiecej tak:
        ----------SGLSET!.text+1B13----------

Mozesz teraz wylaczyc pulapke piszac:
        :bd 0

Aby uaktywnic ja pozniej wystarczy napisac:
        :be 0

Pierwsza linia w oknie kodu wyglada tak:
        CALL    [USER32!GetDlgItemTextA]

Aby   zobaczyc  linie  powyzej,  nacisnij  Ctrl+StrzalkaGora  kilka  razy,  az
zobaczysz linie ponizej. Jesli nie wiesz nic o Assemblerze, czytaj komentarze,
ktore dodalem do lini.
     RET                                     ; Koniec funkcji
     PUSH    EBP                             ; Poczatek funkcji
     MOV     EBP, ESP                        ; ...
     SUB     ESP, 0000009C                   ; ...
     PUSH    ESI                             ; ...
 >   LEA     EAX, [EBP-34]                   ; EAX = EBP-34
     PUSH    EDI                             ; ...
     MOVE    ESI, ECX                        ; ...
     PUSH    32                              ; Zapisz: Max dlugosc ciagu
 >   PUSH    EAX                             ; Zapisz: Adres  buforu tekstowego
     PUSH    000003F4                        ; Zapisz: Identyfikator kontroli
     PUSH    DWORD   PTR   [ESI+1C]          ; Zapisz: Obsluga okna dialogowego
     CALL    [USER32!GetDlgItemTextA]        ; Pobierz tekst

Komendy  PUSH oznaczaja zapisanie wartosci do pozniejszego uzycia. Zaznaczylem
wazne  linie  znakiem  '>'.  Ogladajac  powyzszy kod wiesz, ze adres do bufora
tekstowego  jest  zapisany  w EAX, i EAX w EBP-34. Wiec teraz obejrzymy EBP-34
korzystajac z polecenia:
        :d ebp-3

Powiniennes moc teraz zobaczyc, to co wpisales, jesli spojrzysz w okno danych.
Teraz poszukamy miejsca, gdzie twoj kod jest porownywany z prawdziwym. Wiec
bedziemy poruszac sie krokowo, po jednej instrukcji, poprzez nacisniecie
klawisza F10, az znajdziemy cos dotyczacego EBP-34... Nie trzeba dlugo szukac,
zeby wyskoczylo cos takiego:
 >   LEA     EAX, [EBP+FFFFFF64]             ; EAX = EBP-9C
     LEA     ECX, [EBP-34]                   ; ECX = EBP-34
     PUSH    EAX                             ; Zapisz: EAX
     PUSH    ECX                             ; Zapisz: ECX
 >   CALL    00403DD0                        ; Wywolaj funkcje
     ADD     ESP, 08                         ; Usun zapisane informacje
     TEST    EAX, EAX                        ; Sprawdz zwrocenie wyniku
     JNZ     00402BC0                        ; Skok jesli nie zero

Wedlug mnie wyglada to na funkcje porownujaca. Dziala to mniej wiecej tak:
        *  Wprowadz  dwa  ciagi,  zwroc zero jesli sa takie same, jesli inne -
rozne od zera

Dlaczego  program  porownuje  ciag, z tym, ktory wpisales ? Zeby zobaczyc, czy
jest wlasciwy ! (Twoj jest juz prawdopodobnie zly)

Wiec    co   jest   ukryte   za   adresem   [EBP+FFFFFF64]   ?   SoftICE   nie
manipuluje dobrze liczbami ujemnymi,  wiec, zeby znalezc prawdziwa wartosc, musisz dokonac
tego obliczenia:
        100000000 - FFFFFF64 = 9C

Mozesz dokonac obliczen w SoftICE tak:
        :? 0-FFFFFF64

Liczba  100000000 jest za duza dla SoftICE, ale z drugiej strony rezultat jest
ten sam.

A teraz... czas, zeby zobaczyc, co sie kryje za EBP-9C... Zrob to tak:
        :d ebp-9c

Okno  danych  pokaze  ci  teraz  dlugi  rzad  liczb  -  kod ! Ale pamietaj, co
powiedzialem  wczesniej...  dwa  typy rejestracji daja dwa kody... wiec pozniej
bedziesz musial zapisac kod, ktory zdobyles, kontynuujemy prace krokowa z F10...
Doszlismy do tej czesci kodu:
 >   LEA     EAX, [EBP-68]                   ; EAX = EBP-68
     LEA     ECX, [EBP-34]                   ; ECX = EBP-34
     PUSH    EAX                             ; Zapisz: EAX
     PUSH    ECX                             ; Zapisz: ECX
 >   CALL    00403DD0                        ; Wywolaj jeszcze raz funkcje
     ADD     ESP, 08                         ; Wyczysc zapisana informacje
     TEST    EAX, EAX                        ; Sprawdz zwrocony wynik
     JNZ     00402BFF                        ; Skok jesli nie zero

A co mozemy odnalezc pod adresem EBP-68 ? Wiec... drugi kod rejestracyjny !
        :d ebp-68

To wszystko... Mam nadzieje, ze wszystko dziala !


3.2  Command Line 95 - Prosta rejestracja nazwy/kodu i tworzenie generatora
===========================================================================
Jest to ladny, przykladowy program, z bardzo latwym przeliczaniem kodu.



3.1.1 Badanie programu
======================
Sprawdziles  program  i  wiesz,  ze jest 32-bitowa aplikacja, zadajaca Nazwy i
Kodu w okienku rejestracyjnym.
Wiec zaczynajmy !


3.1.2 Pulapki na procedury
==========================
Zrobimy  to  jak  z TaskLockiem - ustawimy pulapki. Mozemy postawic pulapke na
obydwie    z    najbardziej    prawdopodobnych   funkcji:   GetWindowTextA   i
GetDlgItemTextA. Nacisnij Ctrl+D, zeby wywolac SoftICE i wpisz:
        :bpx getwindowtexta
        :bpx getdlgitemtexta

Teraz  przejdz  do  okienka  rejestracji  i  wpisz nazwe i jakis numer (liczba
calkowita  jest najzwyczajniejszym kodem). Ja wpisalem cos takiego i wcisnalem
OK...
        Nazwa:   ED!SON '96
        Kod:     12345

Program zatrzymal sie na GetDlgItemTextA. Tak jak w TaskLock, naciskamy F11
zeby  wrocic  do  wywolanej funkcji. Przewijamy w gore przez Ctrl+Up i widzimy
cos takiego:
     MOV     ESI, [ESP+0C]
     PUSH    1E                              ; Maksymalna dlugosc
     PUSH    0040A680                        ; Adres do bufora
     PUSH    000003ED                        ; Kontrola obslugi
     PUSH    ESI                             ; Obsluga okienka dialogowego
     CALL    [User32!GetDlgItemTextA]

Numer 40A680 wyglada na interesujacy nas, wiec sprawdzmy ten adres:
        :d 40a680

I  co  pokaze  nam w oknie danych, jesli nie wprowadzilismy nazwy. OK, widzimy
ponizej czesc kodu, mowiaca nam :
     PUSH    00                              ; (nie dotyczy)
     PUSH    00                              ; (nie dotyczy)
     PUSH    000003F6                        ; Kontrola obslugi
     MOV     EDI, 0040A680                   ; Zapisz adres do bufora
     PUSH    ESI                             ; Obsluga okienka dialogowego
     CALL    [User32!GetDlgItemInt]

GetDlgItemInt  jest  podobne  do GetDlgItemText, ale zwraca liczbe calkowita z
okienka  tekstowego. Jest to zwracane do EAX, wiec zrobimy krok do poprzedniej
instrukcji, i spojrzmy w okno rejestrow... U mnie wyglada to tak:
        EAX=00003039


A ile jest w hex 3039 ? Wpisz:
        :? 3039

I dostajesz cos takiego :
        00003039  0000012345  "09"
        ^ hex     ^ dec       ^ ascii

I  jak  juz widzisz (i juz sie pewnie domyslasz), jest to wpisany przez ciebie
kod.  Ok,  co  teraz  ?  Spojrz  na kod wynikajacy, najpierw zwrocony kod jest
zapisywany:
     MOV     [0040A548], EAX                 ; Zapisz zwrocony kod
     MOV     EDX, EAX                        ; Umiesc zwrocony kod takze w DX


3.1.3 Obliczanie kodu
=====================
Nastepnie kod jest obliczany!
     MOV     ECX,  FFFFFFFF                  ; Te rzedy obliczaja dlugosc ciagu
     SUB     EAX, EAX                        ; .
     REPNZ SCASB                             ; .
     NOT     ECX                             ; .
     DEC     ECX                             ; ECX zawiera teraz dlugosc
     MOVSX   EAX, BYTE PTR [0040A680]        ; Pobierz bajt z 40A680
     IMUL    ECX, EAX                        ; ECX = ECX * EAX
     SHL     ECX, 0A                         ; Przesuniecie w lewo krokowo 0A
     ADD     ECX, 0002F8CC                   ; Dodaj 2f8cc do wyniku
     MOV     [0040A664], ECX

I sprawdzany...
        CMP     ECX, EDX                        ; Porownanie kodow
        JZ      00402DA6                        ; Jesli sa takie same, skok...

Kiedy   doszedles   krokowo  do  kodu  porownujacego,  mozesz  sprawdzic  jaki
RZECZYWISCIE powinien byc twoj kod :
        :? ecx

U mnie wyglada to tak:
        000DC0CC  0000901324

To znaczy, ze wlasciwy kod dla mnie to 901324.

Wiec  nacisnij  F5  lub  Ctrl+D  aby opuscic SoftICE, i sprobuj jeszcze raz, z
PRAWDZIWYM kodem, ale w formie dziesietnej. To dziala !


4.  TWORZENIE GENERATORA NUMEROW DLA COMMAND LINE 95
====================================================
Spojrzmy  na kod obliczajacy (powyzej) i przeksztalcmy go na C. Stworzylem ten
prosty opis , jak obliczny jest kod:
    code = ( (uppercase_first_char * length_of_string) << 0x0A) + 0x2f8cc;

Uwaga  (1): Nie mozna zapomniec, ze wszystkie znaki sa konwertowane na wielkie
litery, kiedy wpisujesz je w okienku tekstowym, wiec musimy zrobic tak samo.

Uwaga (2): "<< 0x0A" znaczy "multiply with 2^10"

Caly program napisany w C powinien wygladac tak:

        #include <string.h>
        #include <stdio.h>

        int main()
        {
                unsigned long code;
                unsigned char buffer[0x1e];

                printf("CommandLine95 Keymaker by ED!SON '96\n");
                printf("Podaj nazwe:   ");
                gets(buffer);

                strupr(buffer);
                code = ( ((unsigned long)buffer[0] *
                        (unsigned long)strlen(buffer))
                        << 0x0A) + 0x2f8cc;

                printf("Twoj kod to: %lu", code);

                return 0;
        }

Zrobione!


4. WYKORZYSTYWANIE PUSH I CALL
==============================
Spojrzmy jeszcze raz na wycinek kodu z TaskLock :

     PUSH    32                              ; Zapisz: Max dlugosc ciagu
     PUSH    EAX                             ; Zapisz: Adres  buforu tekstowego
     PUSH    000003F4                        ; Zapisz: Identyfikator kontroli
     PUSH    DWORD   PTR   [ESI+1C]          ; Zapisz: Obsluga okna dialogowego
     CALL    [USER32!GetDlgItemTextA]        ; Pobierz tekst


Jesli wywolasz to z programu w C, wywolanie bedzie wygladac tak:

  GetDlgItemTextA(hwndDlg, 0x3F4, buffer, 0x32);
                  ^ [ESI+1C]      ^ EAX

PUSH pamieta dane o czyms wywolanym ze stosu. W rezultacie kazde PUSH
odklada nowa czesc danych na gore stosu.


5. O PROGRAMACH NAPISANYCH W VISUAL BASIC
=========================================
Pliki  .EXE  napisane  w  VB nie sa prawdziwymi, skompilowanymi EXE. Zawieraja
one  po  prostu  kod,  wywolujacy  VBRUNxxx.DLL,  ktory  czyta dane z EXE, aby
uruchomic  program. To jest odpowiedz, dlaczego programy Visual Basic sa takie
wolne.  Kiedy  plik  EXE  nie  jest  prawdziwy,  nie mozesz go zdeassemblowac,
mozesz  tylko  znalesc  wywolanie  do  DLL  i  duzo smieci, a kiedy uruchomisz
debuggera, takze zatrzymasz sie na DLL.
Rozwiazaniem jest dekompilator. Istnieje dekompilator dla Visual Basic 2 & 3,
stworzony  przez  kogos  pod  ksywa  DoDi. Jest to shareware i jest dostepny w
Internecie  (Patrz  Dodatek  C). Dla Windows 95, istnieje Visual Basic version 4
tworzacy 32-bitowe aplikacje, i niestety nie istnieje dla nich dekompilator.
Uwaga: Nieprawdziwi (lub nieintelogentni) programisci tworza programy w Basicu.


A. LADOWANIE SYMBOLI W SOFTICE
==============================
Zeby sprawdzic, czy SoftICE zaladowal symbole dla GetWindowText, wejdz do SoftICE
naciskajac Ctrl+D i napisz cos takiego :
       :exp getwindowtext
Jesli  nie wszystkie funkcje GetWindowText zostaly wyswietlone, musisz zmienic
plik    \SIW95\WINICE.DAT   przez   usuniecie   znakow   komentarza   (';')  z
'exp=' z lini poprzedzonych tym tekstem : "Examples of export symbols that can be included
for  chicago"  w  poblizu  konca  pliku.  Mozesz  usunac  znaki  komentarza ze
wszystkich linii, lub aby oszczedzic pamiec, tylko z tych plikow: kernel32.dll, user32.dll,
gdi32.dll, ktore to sa najwazniejsze.
Kiedy wprowadzisz zmiany, uruchom ponownie komputer, zeby wprowadzic zmiany.


B.  Skladnia funkcji
====================
Zawsze  duzo  latwiej jest zrozumiec, wywolanie funkcji o ktorej mowimy, kiedy
je zadeklarujesz, wiec zrob to :

int GetWindowText(int windowhandle, char *buffer, int maxlen);
int GetDlgItemText(int dialoghandle, int controlid, char *buffer, int maxlen);
int GetDlgItemInt(int dialoghandle, int controlid, int *flag, int type);

Po dokladniejszy opis funkcji, sprawdz "Windows/Win32 programming reference".


C. GDZIE UZYSKAC OPROGRAMOWANIE
===============================
NARZEDZIA CRACKERSKIE
 SoftICE/Win 2.oo:  http://www.geocities.com/SoHo/2680/cracking.html
 VB Decompiler:     ftp://ftp.sn.no/user/balchen/vb/decompiler/

PRZYKLADOWE PROGRAMY
 TaskLock:          http://users.aol.com/Sajernigan/sgllck30.zip
 CommandLine 95:    ftp://ftp.winsite.com/pub/pc/win95/miscutil/cline95.zip


D. KONTAKT ZE MNA
=================
Na IRC (EFNet):        In #Ucf96, #Cracking
Przez e-mail:          edison@ccnux.utm.my LUB an461165@anon.penet.fi
Na mojej stronie:      http://www.geocities.com/SoHo/2680/cracking.html


E. OD TLUMACZA
==============
Orginalny tekst zostal napisany przez ed!son'a po angielsku. Nie dodawalem w
tym   tekscie   niczego   nowego,  jedynie  ten  punkt.  Staralem  sie  dobrze
przetlumaczyc  ten tekst, choc chwilami bywalo to trudne. Jest to moj pierwszy
tekst  przetlumaczony  z angielskiego, a dotyczacy crackingu, dlatego prosze o
wyrozumialosc.
BTW:  Jesli chcesz byc naprawde dobrym crackerem, zapisz sie na liste Crackpl,
co mozna zrobic pod adresem:

http://friko6.onet.pl/ns/gcrkpl/


Wszystkie sugestie, uwagi, pomysly prosze kierowac na:

warp@kki.net.pl
      lub
warp_4@friko6.onet.pl

Warp

==============================================================================
