Capire un generatore di seriale: II parte
Salve giovani amanti dell'assembler, oggi andremo avanti con la lezione sui generatori di chiave e analizzeremo il codice di un programma che usiamo tutti o quasi: il MIRC 5.31. Utilizzeremo come al solito SOFTICE. Lanciamo Mirc, andiamo sotto HELP|REGISTER ed inseriamo il nome e il codice numerico. Ctrl-D e fissiamo un bel BPX MESSAGEBOXA, F5 per ritornare su Mirc, diamo l'OK e...BOOM eccoci su Softice, premiamo F12 e ci ritroviamo su Mirc che ci fa comparire la finestra di messaggio che ci dice che abbiamo sbagliato codice (...ancora per poco), premiamo OK e rieccoci dentro Softice, ed esattamente qui:
:00437E9C push 00000010
:00437E9E push 004B4EC2
:00437EA3 push 004B4E2C
:00437EA8 mov eax, dword ptr [ebp+08]
:00437EAB push eax
:00437EAC Call USER32.MessageBoxA
:00437EB1 push 00000083 --------------> punto di atterraggio
:00437EB6 mov eax, dword ptr [ebp+08]
Bene ora non vi resta che fare un pò di scroll up ovvero far scorrere verso l'alto per vedere quale è la parte di codice che chiama la MessageBox; scorrete scorrete ed arriverete qui:
:00437DE7 push 004C07CC -----------> fate d 4C07CC leggerete il codice che avete scritto
:00437DEC push 004C0510 -----------> qui troverete il nome che avete scritto
:00437DF1 call 004822D0 -----------> call che effettua il controllo della validità e ritorna il valore
:00437DF6 add esp, 00000008 in EAX
:00437DF9 test eax, eax
:00437DFB je 00437E67 -----------> se EAX = 0 allora salta alla MessageBox di prima
:00437DFD push 004B77A4
:00437E02 push 004B4DC0
Avrete capito che bisognerà andare a spulciare nella CALL che sta all'indirizzo 00437DF1; facciamo un bel Trace della call:
:004822D0 push ebp
:004822D1 mov ebp, esp
:004822D3 push ebx
:004822D4 push esi
:004822D5 push edi
:004822D6 mov esi, dword ptr [ebp+0C]
:004822D9 mov ebx, dword ptr [ebp+08]
:004822DC push ebx -------------> Scrivete d ebx comparirà il nome che avete inserito
:004822DD call 004A4060 ------------> calcola la lunghezza del nome inserito e la mette in EAX
:004822E2 pop ecx
:004822E3 cmp eax, 00000005 ----> se la lunghezza del nome inserito è più piccola di 5, non salta
:004822E6 jnb 004822EC ------> quindi il nome da inserire deve essere più lungo di 5
:004822E8 xor eax, eax
:004822EA jmp 00482363
:004822EC push esi
:004822ED push ebx
:004822EE call 004821F0 -------> un'altra Call che fa un controllo su nome e codice
:004822F3 add esp, 00000008
:004822F6 test eax, eax -------> la Call ritorna EAX= 0 se non è giusto il codice altrimenti EAX=1
:004822F8 je 00482301
:004822FA mov eax, 00000001
:004822FF jmp 00482363
Non siamo ancora arrivati al pezzo di codice che ci serve per capire come viene generato il vero codice; dobbiamo fare il Trace della CALL che sta a 004822EE, quindi:
.....................
:004821FC push 0000002D --------> 2D non è altro che il "-" (trattino), ciò vuol dire che il codice vero
:004821FE push esi da inserire deve contenere il trattino e che quindi sarà composto
:004821FF call 004A400C da 2 parti. Questa Call verifica l'esistenza del trattino e ritorna 0 in
:00482204 add esp, 00000008 EAX se non c'è.
:00482207 mov ebx, eax
:00482209 test ebx, ebx
:0048220B jne 00482214
....................
....................
00482254 add ecx, 00000003 --------> questa parte calcola la prima parte di codice. In ECX abbiamo
:00482257 cmp edx, dword ptr [ebp-0C] il nome che abbiamo inserito. Osservate come
:0048225A jge 00482278 aggiunga a ECX il valore 00000003
:0048225C movzx esi, byte ptr [ecx] ------> muove in ESI i caratteri in Ascii esadecimale dal 3 in poi
:0048225F imul esi, dword ptr [4*eax+004BBB44] -----> moltiplica ESI per il risultato della parentesi e
:00482267 add ebx, esi mette il risultato in ESI, per poi sommarlo a EBX
:00482269 inc eax ---------> incrementa il valore di EAX che partiva da 0
:0048226A cmp eax, 00000026
:0048226D jle 00482271
:0048226F xor eax, eax
:00482271 inc edx -----------> incrementa EDX
:00482272 inc ecx -----------> incrementa ECX
:00482273 cmp edx, dword ptr [ebp-0C] -----------> ripete il loop finchè EDX non è uguale alla
:00482276 jl 0048225C lunghezza del nome che avete inserito.
Ok, mi sembra abbastanza facile da capire come viene generata la prima parte del codice, l'unica cosa che vi risulterà difficile da capire è cosa avviene nel prodotto tra ESI e [.....]. Allora che vuol dire 4*eax+004BBB44? Ve lo spiego subito. Se scrivete d 004BBB44, vedrete nella finestra una cosa tipo questa:
0B 00 00 00 06 00 00 00 11 00 00 00 0C
0C 00 00 00 0E 00 00 00 05 00 00 00 0C
....................................................
Sapendo che Eax parte da 0, allora nel primo loop il ESI verrà moltiplicato per B, nel secondo loop Esi verrà moltiplicato per 6, nel terzo per 11, nel quarto per C e così via...Capito?!?!? Facile vero!!! Bene ora analizziamo l'altra parte di codice come viene costruita:
...........................
:0048228D add ecx, 00000003 ---------> ancora una volta il nome viene preso dalla 3 lettera
:00482290 cmp edx, dword ptr [ebp-0C]
:00482293 jge 004822B8
:00482295 movzx esi, byte ptr [ecx] ----> muove in ESI i caratteri ASCii Esadec. del nome dal 3 in poi
:00482298 movzx edi, byte ptr [ecx-01] ---> muove in EDI i caratteri Ascii Esa del nome dal 2 in poi
:0048229C imul esi, edi --------> moltiplica ESI per EDI e il mette il risultato in ESI
:0048229F imul esi, dword ptr [4*eax+004BBB44] -----> moltiplica ESI per il fattore tra le [.....]
:004822A7 add ebx, esi --------> somma ESI a EBX e mette il risultato in EBX
:004822A9 inc eax
:004822AA cmp eax, 00000026
:004822AD jle 004822B1
:004822AF xor eax, eax
:004822B1 inc edx -----------> incrementa EDX
:004822B2 inc ecx ----------> incrementa ECX
:004822B3 cmp edx, dword ptr [ebp-0C] ----> ripete il loop se EDX è minore della lunghezza del nome
:004822B6 jl 00482295
Insomma, anche questa seconda parte del codice ora è svelata. Quando creerete il vostro bel programmino di keygen, ricordatevi bene tutti i percorsi dell'algoritmo di calcolo, nonchè del trattino..... inoltre ricordatevi di citarmi nel programma!!!!!
Purtroppo io programmo in VB quindi non vi scriverò il programma keygen, questo toccherà a voi implementarlo con il linguaggio che sapete usare di più. A presto miei fidi!!!!
Ringraziamenti: a tutto il gruppo RingZer0 per il supporto Tecnico e Morale, ed a Insanity perchè pubblica i miei tutorial.
