Allegato

Introduzione

Non c'è molto da dire, non sono mai stato bravo a scrivere comunque, eccoci qui con un tutorial, Music Maker XP o meglio melody raiser... ._. molti di voi mi odieranno perchè è un programma che è RPG maker-related infatti è stato scritto da Ojima ma sono legato "sentimentalmente" a questo programma infatti è il primo programma che provai a crackare moooolto tempo fa e Sixterm mi diede una mano, e adesso? adesso vediamo un approccio più profondo a questo programma...

Tools usati

TRW2000 (o un qualsiasi debugger)

DeDe v 3.50.02

MASM 8

 

URL o FTP del programma

Music Maker XP: cercate in giro non saprei dove pescarlo ormai ._. comunque l'ho messo nell'allegato insieme al sorgente del keygen.

Essay

Apriamo il caro DeDe visto che il programma è in delphi e andiamo a cercare la Form Regist e apriamo l'evento
ButtonOkClick. Scendiamo giù con il cursore e vediamo:

0046F4EB mov edx, $00000002 0046F4F0 mov eax, [ebp-$08] * Reference to: Unit_00466BB0.Proc_00466C10 | 0046F4F3 call 00466C10 0046F4F8 test al, al 0046F4FA jnz 0046F546 * Possible String Reference to: 'Chiave di licenza non valida.La chi | ave non è valida. Assicurati di ave | rdigitato il nome e la chiave corre | tti. ' | 0046F4FC mov eax, $0046F668

Apriamo il debugger e settiamo un break point sulla call, dumpiamo eax (d eax) e vediamo che in eax viene messo il nostro seriale,
la call seguente sicuramente è quella del calcolo, subito dopo un bel test al,al cosa significa questo?
vede se al è 1 se lo è salta a "Ok il prezzo è giusto" altrimenti il seriale non è quello giusto, soluzione?
entrare nella call... alla fine della stessa troviamo:

00466C94 mov al, byte ptr [esp+$08] 00466C98 add esp, +$0C 00466C9B pop edi 00466C9C pop esi 00466C9D pop ebx 00466C9E ret

modifichiamo il mov al, byte ptr [esp+$08] a 00466C94 in mov al,01 e il gioco è fatto il programma dirà
bravoooooo ti sei registratoooo. Ma noi vogliamo qualcosa di più :>
(piccola parentesi tutti i programmi di Ojima possono essere crackati così...
anche l'algoritmo della key generation è uguale cambia solo un numerino... ^__^)

Se provate vedrete che dopo tre volte che proviamo a inserire il seriale chiude il programma,
risolviamo velocemente questo problema noppando un fastidioso inc: passiamo oltre la call e andando
più avanti notiamo immediatamente un inc seguito da un cmp, noppiamo senza pensarci due volte.

0046F522 inc dword ptr [ebx+$02F0] ;noppa qui 0046F528 cmp dword ptr [ebx+$02F0], +$03 0046F52F jnz 0046F5EB

Ritorniamo alla nostra call, un veloce sguardo all'interno della stessa ci fa subito capire che il seriale è di sette caratteri, un punto in più per noi

adesso apriamo il debugger, e giriamo un pò per la call, arrivando alla fine dovreste esservene accorti anche
voi cosa fa hehehe

vi ricordo che in edx abbiamo il valore 0x02, questa è la call disassemblata e commentata:

push ebx push esi push edi add esp, -$0C mov [esp+$04], edx mov [esp], eax mov byte ptr [esp+$08], $00 mov eax, [esp] ;eax = seriale * Reference to: system.@LStrLen:Integer; | call 00403DA0 cmp eax, +$07 jnz label1 ;il seriale deve essere di sette caratteri mov byte ptr [esp+$08], $01 xor edx, edx mov esi, $00000001 loop1: mov eax, [esp] ;eax = seriale movzx eax, byte ptr [eax+esi-$01] ;in eax carattere successivo del seriale add edx, eax ;edx=eax+edx mov eax, edx ;eax=edx imul edx ;eax=edx*eax (cioè calcola il quadrato) mov edx, eax ;edx=eax inc esi ;esi++ cmp esi, +$06 jnz loop1 ;se esi <> 6 salta a loop1 mov esi, $00000006 ;esi = 6 (lo sò non ha molto senso ._.) (se avete notato esi viene incrementato da 1 a 6 quindi effettua 5 volte il ciclo, cioè per i primi 5 caratteri del seriale) loopf: mov eax, [esp] ;eax = seriale mov cl, byte ptr [eax+esi-$01] ;cl = seriale[esi-1] or edi, -$01 ;pulisce edi mov eax, $00000001 ;eax = 0x01 loop2: * Possible String Reference to: 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789' | mov ebx, $00466CA8 ;ebx = stringa magica cmp cl, byte ptr [ebx+eax-$01] ; jnz label2 ;se cl <> da stringamagica[eax-1] salta a label2 mov edi, eax ;altrimenti edi = eax label2: inc eax ;eax++ cmp eax, +$21 ; jnz loop2 ;se eax <> 0x21 continua ciclo altrimenti esci mov eax, [esp+$04] ;eax = 0x02 add eax, edx ;eax = eax+edx and eax, +$1F ;eax = eax & 0x1F inc eax ;eax++ cmp eax, edi ; jz label4 ;se eax == edi salta a label4 mov byte ptr [esp+$08], $00 ;altrimenti byte[esp+08] = 0x00 hai cannnato! label4: shr edx, $05 ;edx = edx>>5 inc esi ;esi++ cmp esi, +$08 ; jnz loopf ;se esi <> 0x08 continua ciclo altrimenti esci label1: mov al, byte ptr [esp+$08] ;al = byte[esp+08] add esp, +$0C pop edi pop esi pop ebx ret ;fineeeeeeeeee

Ho rinominato i vari jump e messo delle etichette, a me ha aiutato molto

Vediamo un'attimo come funziona queta routine, siamo reverser giusto? e allora partiamo dalla fine confronta
gli ultimi due caratteri del seriale (infatti ESI prima viene messo come 6 e poi viene incrementato e confrontato
con 8, quindi 2 caratteri)
Abbiamo visto che vengono fatti 2 cicli nel loop: ESI-1 sarà prima 5 (quindi il sesto carattere del seriale)
e poi 6 (quindi il settimo) qui:

mov cl, byte ptr [eax+esi-$01] ;cl = seriale[esi-1]

questo significa che i primi 5 caratteri del seriale possono essere qualsiasi cosa, mentre gli ultimi 2 vengono calcolati sui primi 5.
Calcola il primo ma lo calcola prendendo il "numero corrispondente al carattere nella stringa magica, quindi se è A sarà 1 se è B sarà 2 etc, poi fa un ciclo per vedere a quale dei caratteri corrisponde e mette il "numero" corrispondente in EDI, in seguito lo confronterà con quello che viene calcolato.

Keygen? bè se siete arrivati fin qui e avete capito quello che ho scritto... lo sò non sò scrivere
(in fondo è il mio primo tutorial!) dovreste riuscire a fare un keygen.
Comunque c'è il sorgente, ancora più incasinato del tutorial

INVOKE GetDlgItemText, hWnd, IDC_NAME, ADDR sName, SIZEOF sName cmp eax, 05h jne ValidityError ; Generation routine xor edx, edx mov esi, 00000001h loop1: lea eax, sName movzx eax, byte ptr[eax+esi-1] add edx, eax mov eax, edx imul edx mov edx, eax inc esi cmp esi, 06h jnz loop1 mov esi, 00000005h lea eax, sName mov cl, byte ptr[eax+esi-1] or edi, (-1) mov eax, 00000001h loop2: lea ebx, sMagic ;ABCDEFGHJKLMNPQRSTUVWXYZ23456789 cmp cl, byte ptr [ebx+eax-1] jnz label2 mov edi, eax label2: inc eax cmp eax, 21h jnz loop2 mov eax, 00000002h add eax, edx and eax, 1Fh inc eax lea esi, sName+5 mov eax, [eax+ebx-1] mov [esi], eax shr edx, 5 mov esi, 0000006h lea eax, sName mov cl, byte ptr[eax+esi-1] or edi, (-1) mov eax, 00000001h loop3: lea ebx, sMagic cmp cl, byte ptr [ebx+eax-1] jnz label3 mov edi, eax label3: inc eax cmp eax, 21h jnz loop3 mov eax, 00000002h add eax, edx and eax, 1Fh inc eax lea edx, sName+6 mov eax, [eax+ebx-1] mov [edx], eax lea edx, sName+7 xor eax, eax mov [edx], eax INVOKE SetDlgItemText, hWnd, IDC_SERIAL, ADDR sName jmp EndGen

Se notate la differenza tra il codice è minima (infatti si può rippare l'asm) adesso, vi chiederete, ma dove ha messo il loop?
L'ho tolto, "copiando" due volte le istruzioni che lo compongono, visto che viene ripetuto due volte...non è una bella soluzione
ma almeno è pratica in mezzo hai due ovviamente ho rimesso le cose "a posto" inserendo due righe di codice per sistemare il tutto mettendo il contenuto dei registri come dovrebbe effettivamente stare.

shr edx, 5 mov esi, 0000006h lea eax, sName mov cl, byte ptr[eax+esi-1] or edi, (-1) mov eax, 00000001h

Buon divertimento! E non ridete troppo a vedere il sorcio del keygen è il primo che ho scritto finora.

                                                                                                              ev0...entuale firmetta

Note finali

Credo sia stato un buon esercizio di keygenning abbastanza facile.

Saluto GeO, Syxtem (ehehehe te lo ricordi ancora il tutorial che scrivesti per me?)
Il que che si impegna a mantenere un sito importante come questo, il geddone, ntos, active85k, e tutti gli
altri schizzati di #crack-it, e immancabilmente BlackDemon.
un ringraziamento particolare a Counterwood per il template del keygen

Disclaimer

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 che ogni sviluppatore ha dovuto portare avanti per fornire ai rispettivi consumatori i migliori prodotti possibili.

Reversiamo al solo scopo informativo e per migliorare la nostra conoscenza del linguaggio Assembly.