==========================================================================
$                                                                        $
$                           TuToriaL by Tymon                            $
$                                 What:                                  $
$                     Official TMG KeyGenMe 2 by tE!                     $
$                                                                        $
==========================================================================

.AbOuT

Oki, czas na TMG keygenme. Jak mozna w kilku slowach skomentowac ten  tut?
Znowu RSA :). Ja jednak uwarzam,  ze warto zajrzec do tego keygenme.  Why?
Moze dlatego, ze jest to  kgme samego tE!, ktory napisal  wlasnie RSAtool?
Wydaje  mi  sie,  ze  to  wystarczajacy  argument,  wiec  nie  ma  co  sie
rozpisywac. Moze zaczniemy :)

TOOLS: SoftIce, RSATool, ??? chyba wszystko

.starT

Oki, otwieramy  kgme i  mamy 3  edity do  uzupelnienia. So, Tymon, Polska,
34512, i lapiemy kgme na SendMessageA and ...

                push    offset _name
                push    3Dh
                push    0Dh
                push    ds:dword_4020DC
                call    j_SendMessageA
                cmp     eax, 5
                jl      loc_40139B              <-- name >= 5
                mov     [ebp+var_4], eax
                push    offset _company
                push    3Dh
                push    0Dh
                push    ds:dword_4020E0
                call    j_SendMessageA
                cmp     eax, 5
                jl      loc_4013B4              <-- comp >= 5
                mov     [ebp+var_8], eax
                push    offset _serial
                push    32h
                push    0Dh
                push    ds:dword_4020E4
                call    j_SendMessageA
                mov     ds:word_402370, 0Ah
                push    3
                xor     edx, edx
                imul    eax, 7B5h
                pop     ebx
                div     ebx
                lea     eax, [eax-66C2h]
                cmp     eax, 1
                sbb     eax, eax
                jz      loc_401382

Hmm...  Z tego  kawalka wiemy,  ze name  i company  musza miec  po min.  5
znakow. Sprawdzana jest tez dlugosc seriala, ale wedlug procki. Jak  widac
cala procedurka jest  odwracalna, wiec obliczamy  poprawna ilosc bajtow  w
s/n.

        xor     eax, eax
        inc     eax             ; rownoznaczne z mov eax, 1
        add     eax, 66C2h
        imul    eax, 03h
        mov     ebx, 7B5h
        div     ebx

Wynik powstaje w  eax. My oczywiscie  nie piszemy proga  do obliczenia, bo
wszystkie te dzialania mozna  spokojnie wykonac pod sice.  Oki, ostateczny
wynik to 28h, czyli  40dec. Co z tego  wynika? To proste s/n  musi miec 40
znakow.

                mov     edi, offset _dwordSerial
                mov     esi, offset _serial
                push    esi
                call    j_CharUpperA
                push    14h
                pop     ecx

_conv:                                  ; CODE XREF: sub_401187+CDj
                lodsw
                and     ax, 7F7Fh
                sub     ax, 3030h
                cmp     al, 19h
                ja      _sorry
                cmp     ah, 19h
                ja      _sorry
                movzx   ebx, ah
                movzx   eax, al
                mov     al, ds:byte_401258[eax]
                or      al, ds:byte_401273[ebx]
                stosb
                dec     ecx
                jg      short _conv

Tutaj, na poczatku znaki naszego  seriala sa konwertowane na duze  litery.
Co sie dzieje dalej? To nic innego jak procka HexString2Dword. W  praktyce
wyglada to tak: '34CD' = 34CDh. Co z tego wynika? Oczywiscie, nasze  znaki
musza  byc  z  przedzialu  0-9 i  A-F.  Oki  lookamy  dalej (btw.  wlasnie
uzmyslowilem sobie, ze przez takie konwersje jak moje w stylu ang -->  pl,
nasz jezyk ojczysty jest zasmiecony :) ) :

                mov     edi, offset _mix
                xor     eax, eax
                push    5
                pop     ecx
                repe stosd

Tu znajduje sie kod  odpowiedzialny za czyszczenie miejsca  przeznaczonego
na mix, ktory powstanie z name i company.

                dec     eax
                mov     esi, offset _name
                mov     edi, offset _mix
                mov     ecx, [ebp+var_4]
                xor     edx, edx

_dalej:                                 ; CODE XREF: sub_401187+159j
                lodsb                           ; laduj bajt z [esi]
                xor     ah, al
                imul    eax, 89177313h
                and     eax, 55AA55AAh
                imul    eax, 12299381h
                xor     eax, 0AA55AA11h
                imul    eax, 61h
                xor     ah, al
                or      eax, 10030118h
                imul    eax, 988279h
                rcl     eax, cl
                xor     [edi+edx], eax
                add     edx, 3
                and     edx, 0Fh
                inc     edx
                dec     ecx
                jg      short _dalej
 
A oto wlasnie pierwsza z procek mixujacuch name.

                mov     esi, offset _company
                mov     edi, offset _mix
                mov     ecx, [ebp+var_8]
                xor     edx, edx

_dalej2:                                ; CODE XREF: sub_401187+1A0j
                lodsb                           ;pobierz bajt z _company
                sub     ah, al
                imul    eax, 89157313h
                and     eax, 55AA55AAh
                imul    eax, 12299387h
                or      eax, 0AA55AA11h
                imul    eax, 61h
                xor     eax, 10010114h
                imul    eax, 7918279h
                xor     ah, al
                rcr     eax, cl
                xor     [edi+edx], eax          ; dosc ciekawy sposob nadpisu :)
                add     edx, 3
                and     edx, 0Fh
                inc     edx
                dec     ecx
                jg      short _dalej2
                sub     eax, [edi+8]
                imul    eax, 34814815h
                add     [edi+10h], eax
                shr     eax, 0Bh
                and     eax, 3
                mov     [edi], al

A tu druga procka, tylko mieli ona _company. Dosc ciekawa forma nadpisu na
miejsce mixu z name ( przez xor ), nie niwelujaca poprzednich obliczen :).
Co dalej?

                push    offset _buffer
                push    offset _SerialDword
                push    offset _N
                call    RSA_encode

I doszlismy do  serca calego KeygenMe,  czyli RSA. Hmm...  co znacza te  3
magiczne znaki? :) Nie bede tego tu opisywal bo wiele razy zostalo to  juz
spisane, zarowno po polsku jak i po angielsku.

                push    5
                pop     ecx
                mov     esi, offset _bufferAdd4
                mov     edi, offset _mix

_sprawdzaj:                             ; CODE XREF: sub_401187+1E0j
                lodsd
                xor     [edi], eax
                jnz     short _sorry
                add     edi, 4
                dec     ecx
                jg      short _sprawdzaj

A tutaj? Oczywiscie porownanie. A co zostaje porownane? Tak jak sie pewnie
domyslales nasz mix(name+company) z RSA_encode(serial). Jak wiec  obliczyc
poprawny s/n? Look, tzn. spojrz :)

        jezeli:   mix(name+company) = RSA_encode(serial),

        to:       s/n = RSA_decode(mix( name+company ))

Jeszcze moze mala sciaga z RSA.

===========================================================================
                       RSA w kilku linijkach
===========================================================================
===========================================================================
                            szyfrowanie
===========================================================================

                           C = M^E mod N

szyfrogram = dane ^ publiczny exponent mod publiczny klucz

C    -    szyfrogram
M    -    warto, ktr chcemy zaszyfrowa
E    -    publiczny exponent
N    -    publiczny klucz
mod  -    reszta z dzielenia
^    -    potegowanie

==========================================================================
                            deszyfrowanie
==========================================================================

                            M = C^D mod N

wartosc_odszyfrowana = szyfrogram ^ prywatny exponent mod klucz publiczny

D    -    prywatny exponent

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

Jezeli podstawimy nasz przypadek pod ostatni wzor to otrzymamy:

                    s/n = mix(name+company)^D mod N

To teraz chyba wszstko jest proste?  No tak, tylko skad mamy wziasc  sobie
to D ? Napisz maila to  tE!, bo przeciez to klucz prywatny,  wiec powinien
miec :) Jak Cie  nie wysmieje to pewnie  Ci wysle :) Ja  tam wykorzystalem
prostszy sposob, czyli skorzystalem z programika tE! RSATool. Tym  wlasnie
obliczymy sobie D. Dla ciekawosci podam wzor obiczenia D:

                        d = e^-1 mod ((p-1)*(q-1))

Hmm... Jak widac potrzebne nam bedzie E, P i Q, czyli publiczny  exponent,
i dwie liczby pierwsze spelniajace rownosc  P*Q = N. Jak widzisz nie  mamy
nawet publicznego exponenta.  Jak myslisz jaka  ma wartosc? Wedlug  mnie (
choc to raczej nie jest regula ) jezeli nie ma E w argumentach do RSA,  to
pewnie  bedzie to  standardowa wartosc,  czyli 10001h  = 65537d.  Jak sie
okazalo w tym przypadku mialem racje. Teraz musimy jeszcze znalezc P i  Q.
Jak to zrobic? Nadszed wlasnie czas  na RSAtool. Otwieramy go i w  miejsce
Modulus wpisujemy nasz N z kgme, czyli:

        D2E9BF9B3D258E479D8CC23C7A33E1F8EBB3ADB1

Teraz wystarczy tylko kliknac Factor N  i ... czekac :) Po kilku  minutach
mamy juz P i Q.

        P = D49CAA009DADB2128673
        Q = FDF4549DF6ACE8640E4B

Po obliczeniu liczb pierwszych, naciskamy Calc. D i teraz juz wiemy, ze ...

        D = C6546E0C11ACCE2543DD1150C4CE7A05A4C8FA3D

Oki, jak teraz obliczyc s/n? Ja skorzystalem z opcji Test w RSAtool.  Tam,
w  miejsce  Cliphertext  (C) wpisujemy  wartosc  naszego  mix(name+com.) i
naciskamy 'Decrypt'. Teraz w tym samym okienku mamy nasz s/n, ale w ASCII.
Mam nadzieje, ze nie musze mowic  co masz robic? Oki, wystarczy wkleic  to
do jakiegos pliku textowego i  spisac wartosc hexowa spod hex-editora.  Po
tym wszystkim wyszlo mi:

        Name:    Tymon
        Company: Polska
        S/n:     9BCD0630AF1C3A80C7300611ECE2C914A750A22E

I mamy info 'Correct'. Teraz  zostaje napisanie keygena, ale to  zostawiam
juz tobie. Najlepiej  pisac pod C++,  ale nic (  procz duzych liczb  ) nie
stoi Ci na przeszkodzie napisac to w asm.

.EnD tzn. KoNieC :)

Cale  KeygenMe  calkiem fajne,  choc  ostatnio temat  RSA  moze jest  zbyt
oklepany, bo czesto  sie o tym  czyta / lamie.  Prawda jest takze,  ze ten
maly prog ma juz swoj wiek i nie jest on najswiezszy ( gdy to czytacie, to
daaawno juz ukazalo sie  keygenmy 4 ). Mozna  tylko pocieszyc, ze to  kgme
bylo  chyba  najprostsze  z  wszystkich tworow  tE!  :).  Oki,  czas chyba
konczyc,  wiec tak  jak zwykle,  masz za  duzy dom,  kasa cie  w kieszeni
uwiera, a moze twoja siostra jest niczego sobie :) mailto: tymon_crk@wp.pl
( jak  bedziesz pisal  o siostrze  to podaj  takze wymiary  :) ).  Oki, na
koniec zdrovko dla wszystkich crackme lamaczy. Jo!

.pS

http://mbe.toya.net.pl      // tutaj powinniscie znalezc RSATool

.GreEtz To:

     ged_ * hauer * Kwasek * snatch * ToMKoL * ved * veneta * zakonna
     all from AAoCG & HTBTeam
