Quello che faremo e' cercare e capire l'algoritmo che genera i seriale di registrazione, ricavarci il codice e quindi eliminare il programma dal nostro HD :)

KYODAI 11.56
Un Solitario? No.. Grazie, Preferisco Reversarlo!!!
Written by **SCiaMaNo**

Kyodai e' un programmino che contiene un'insieme di giochi solitari come il famoso tetris ed altri giochi ad incastro; anche se odio tutti i solitari devo dire che il programma e' ben fatto ed e' tutto in 3D.

Il kyodai.exe e' compresso con l'Aspack 2001 che a quanto pare e' l'unica protezione utilizzata... praticamente non c'e' protezione ;)))

Softice 4.x

http://www.kyodai.com/

Bene bene... possiamo iniziare; avviamo il programma, apriamo la finestra di registrazione ed inseriamo un nome ed un serial a caso, io ho inserito come nome il mio nick SCiaMaNo e come serial 0123456789. Entriamo in softice con ctrl-d e settiamo un break point "bpx hmemcpy", torniamo poi al programma con F5 e clickiamo su "Registrazione"; una volta che sice poppa diamoci sotto con F12 sino a che non ci troviamo all'indirizzo 4995B6:

:004952B6 mov edx, dword ptr [ebp-04]  ---------- si parte da qui'; nome in edx
:004952B9 mov eax, dword ptr [004D107C]
:004952BE mov eax, dword ptr [eax]
---------------
---------------
---------------
:004952E7 call 00403B58
:004952EC mov eax, dword ptr [004D107C]
:004952F1 mov eax, dword ptr [eax]
:004952F3 call 004A5488  ---------- il salto dipende da questa call
:004952F8 test al, al
:004952FA je 00495320  ---------- porta alla messagebox "serial errato"

Togliamo il break point precedente e andiamo avanti con F10 sino a giungere sulla 4952F3 call; subito dopo vi e' un je che salta alla messaggio di codice sbagliato. Entriamo quindi con F8 per trovarci all'indirizzo 4A5488 push, iniziamo a steppare con F10 sino ad incontrare un salto condizionato (4A54D2 jne) che salta verso la messagebox d'errore. Se proviamo ad impedire il salto con r fl z e premiamo F5 ci troviamo registrati :-)
A questo punto potremmo decomprimere l'eseguibile con l'Unaspack, effettuare la modifica con un hex editor qualsiasi noppando o piu' semplicemente modificando il jne in un je ed avremmo patchato il programma; ma questo ci renderebbe soddisfatti??? CERTO CHE NO!!! ;)
Il nostro obiettivo era infatti quello di cercare la routine che genera il seriale, riprendiamo quindi la nostra caccia.

:004A5488 push ebp  ---------- partiamo da qui'
:004A5489 mov ebp, esp 
:004A548B push 00000000
:004A548D push ebx
:004A548E push esi
:004A548F mov esi, eax
:004A5491 xor eax, eax
:004A5493 push ebp
:004A5494 push 004A584E
:004A5499 push dword ptr fs:[eax]
:004A549C mov dword ptr fs:[eax], esp
:004A549F xor ebx, ebx
:004A54A1 mov eax, dword ptr [esi+00052B58]
:004A54A7 test eax, eax
:004A54AE jle 004A57E3
:004A54B4 lea ecx, dword ptr [ebp-04]
:004A54B7 mov edx, dword ptr [esi+00052B58]
:004A54BD mov eax, esi
:004A54BF call 004A1D80  ---------- contiene l'algoritmo del seriale
:004A54C4 mov eax, dword ptr [ebp-04]
:004A54C7 mov edx, dword ptr [esi+00052B5C]
:004A54CD call 00403E90  ---------- decide se il seriale e' corretto
:004A54D2 jne 004A57E3  ---------- se impediamo il salto ci registra
:004A54D8 mov eax, dword ptr [esi+00052B58]

La cosa che si nota subito e che prima del nostro jne ci sono solo due call e questo restringe per fortuna la nostra ricerca. Per cominciare diamo subito un'occhiata alla call immediatamente al di sopra del salto, F8 quindi sulla 4A54CD call e guardate un po che bella sorpresa ;)

:00403E90 push ebx
:00403E91 push esi
:00403E92 push edi
:00403E93 mov esi, eax
:00403E95 mov edi, edx
:00403E97 cmp eax, edx  ---------- confronta i due seriali
:00403E99 je 00403F2E  ---------- se sono uguali ci registra

Ci salta immediatamente agli occhi, solo dopo poche righe di codice, il confronto tra eax ed edx all'indirizzo 403E97 segiuto da un salto condizionato; come resistere a non dare una sbirciata a cosa viene comparato? :)
Spostiamoci con F10 su quella riga di codice e digitiamo un bel d edx e vi troviamo il seriale da noi inserito cioe' 0123456789, in eax invece come ci si aspetta vi e' il seriale giusto 40224459, che corrisponde al nick SCiaMaNo :)))
Ok ora non ci resta che scoprire quale e' l'algoritmo che genera il nostro seriale, mettiamo quindi un breack point sulla call rimasta, precisamente sulla 4A54BF call ed una volta sopra vi entriamo con F8:

:004A1D80 push ebp
:004A1D81 mov ebp, esp
:004A1D83 add esp, FFFFFFF4
:004A1D86 push ebx
:004A1D87 push esi
:004A1D88 push edi
:004A1D89 xor ebx, ebx
:004A1D8B mov dword ptr [ebp-0C], ebx
:004A1D8E mov edi, ecx
:004A1D90 mov dword ptr [ebp-08], edx  ---------- sposta il nome in ebp-08
:004A1D93 mov dword ptr [ebp-04], eax
:004A1D96 mov eax, dword ptr [ebp-08]  ---------- sposta il nome in eax
:004A1D99 call 00403F34
:004A1D9E xor eax, eax  ---------- azzera eax
:004A1DA0 push ebp
:004A1DA1 push 004A1E5D
:004A1DA6 push dword ptr fs:[eax]
:004A1DA9 mov dword ptr fs:[eax], esp
:004A1DAC mov eax, dword ptr [ebp-08]  ---------- mette di nuovo il nome in eax
:004A1DAF call 00403D80  ---------- mette la lunghezza del nome in eax
:004A1DB4 mov edx, dword ptr [ebp-08]  ---------- nome in edx
:004A1DB7 movzx eax, byte ptr [edx+eax-01]  ---------- sposta l'ultimo carattere (o) in eax
:004A1DBC mov edx, dword ptr [ebp-08]  ---------- nome in edx
:004A1DBF movzx edx, byte ptr [edx]  ---------- sposta il primo carattere (S) in edx
:004A1DC2 add eax, edx  ---------- somma l'ultimo ed il primo carattere
:004A1DC4 mov ecx, 0000000A  ---------- mette 0A (10) in ecx
:004A1DC9 xor edx, edx  ---------- azzera edx
:004A1DCB div ecx  ---------- somma precedente diviso 10 con risultato in eax e resto in edx
:004A1DCD add edx, 00000030  ---------- somma resto+30h (48) e ci da il primo numero del seriale
:004A1DD0 mov eax, edi
:004A1DD2 call 00403CA8
:004A1DD7 mov eax, dword ptr [ebp-08]  ---------- muovi il nome in eax
:004A1DDA call 00403D80  ---------- mette la lunghezza del nome in eax (8)
:004A1DDF mov esi, eax  ---------- muove la lunghezza del nome in esi
:004A1DE1 sub esi, 00000002  ---------- esi-2 (6)
:004A1DE4 jl 004A1E20
:004A1DE6 inc esi  ---------- esi+1 (7)
:004A1DE7 mov ebx, 00000002

Da qui' riparte un altro ciclo simile per ricavare il secondo numero del seriale:

Jump at Address:
|:004A1E1E
|
:004A1DEC mov eax, dword ptr [ebp-08]  ----------nome in eax
:004A1DEF movzx eax, byte ptr [eax+ebx-02]  ---------- primo carattere in eax
:004A1DF4 mov edx, dword ptr [ebp-08]  ---------- nome in edx
:004A1DF7 movzx edx, byte ptr [edx+ebx-01]  ---------- secondo carattere in edx
:004A1DFC add eax, edx  ---------- somma primo e secondo carattere
:004A1DFE mov ecx, 0000000A  ---------- muove 10 (0A) in ecx
:004A1E03 xor edx, edx  ---------- azzera edx
:004A1E05 div ecx  ---------- somma diviso 10
:004A1E07 add edx, 00000030  ---------- resto+48 (30h) = secondo numero del seriale
:004A1E0A lea eax, dword ptr [ebp-0C]
:004A1E0D call 00403CA8
:004A1E12 mov edx, dword ptr [ebp-0C]
:004A1E15 mov eax, edi
:004A1E17 call 00403D88
:004A1E1C inc ebx
:004A1E1D dec esi  ---------- esi-1 (6) ; esi indica i cicli ancora da eseguire
:004A1E1E jne 004A1DEC  ---------- se esi=0 continua, altrimenti esegui un altro ciclo

Jump at Address:
|:004A1DE4
|
:004A1E20 mov eax, dword ptr [ebp-08]  ---------- sposta il nome in eax
:004A1E23 call 00403D80  ---------- mette la lunghezza del nome in eax...
:004A1E28 cmp eax, 00000008  ---------- ... e la confronta con 8
:004A1E2B jge 004A1E42  ---------- se minore di 8 non salta e va alla message box d'errore
:004A1E2D mov ecx, edi

Come si puo vedere abbiamo trovato la nostra routine, l'algoritmo e' estrememente semplice:
ad ogni ciclo vengono presi due caratteri, sommati tra loro, divisi per 10 ed il resto sommato a 48; il risultato ottenuto rappresenta un numero che forma il seriale.

1°char + 8°char => S+o => 83+111=194 --> 194:10=19,4 --> 4+48=52 che in ascii e' 4
1°char + 2°char => S+C => 83+67=150 --> 150:10=15 --> 0+48=48 che in ascii e' 0
2°char + 3°char => C+i => 67+105=172 --> 172:10=17,2 --> 2+48=50 che in ascii e' 2
3°char + 4°char => i+a => 105+97=202 --> 202:10=20,2 --> 2+48=50 che in ascii e' 2
4°char + 5°char => a+M => 97+77=174 --> 174:10=17,4 --> 4+48=52 che in ascii e' 4
5°char + 6°char => M+a => 77+97=174 --> 174:10=17,4 --> 4+48=52 che in ascii e' 4
6°char + 7°char => a+N => 97+78=175 --> 175:10=17,5 --> 5+48=53 che in ascii e' 5
7°char + 8°char => N+o => 78+111=189 --> 189:10=18,9 --> 9+48=57 che in ascii e' 9

Quindi la lunghezza del seriale corrisponde sempre a quella del nome. In ultimo all'indirizzo 4A1E28 viene controllato che il nome sia di almeno 8 caratteri, se cosi' non fosse comparirebbe il messaggio di codice errato.
FINE - THE END - GAME OVER.. ecc. :)

                                                                                                                 by **SCiaMaNo**

Salutoni a tutta la UIC che spero diventi sempre meglio!!!

Vorrei ricordare che il software va comprato e non rubato, dovete registrare il vostro prodotto dopo il periodo di valutazione. Non mi ritengo responsabile per eventuali danni causati al vostro computer determinati dall'uso improprio di questo tutorial. Questo documento è stato scritto per invogliare il consumatore a registrare legalmente i propri programmi, e non a fargli fare uso dei tantissimi file crack presenti in rete, infatti tale documento aiuta a comprendere lo sforzo immane che ogni singolo programmatore ha dovuto portare avanti per fornire ai rispettivi consumatori i migliori prodotti possibili.

Noi reversiamo al solo scopo informativo e di miglioramento del linguaggio Assembly.