Goldwave 4.23: Patching, Serial Fishing & Keygen

Written by ParadoxEvil

Scarica qui l'allegato

Ci occuperemo di registrare correttamente il target in questione, di patcharlo in modo da potersi registrare inserendo qualsiasi cosa e di vedere come viene generata la password.

FileMonitor

Hiew

WinDasm

SoftIce

Potete scaricare l'applicazione da www.shareware.com oppure dal sito principale, www.goldwave.com

Goldwave è un ottimo audio tool con svariate opzioni x la registrazione, l'editing e il campionamento di file audio. Pur nn essendo di grosse dimensioni riesce a svolgere il suo compito egregiamente.

Parte Prima: Patching

 

Apriamo il target e alla voce ' Register ' inseriamo dei dati a caso, quindi clicchiamo su OK. Ovviamente il programma ci sparerà il solito messaggio di registrazione non avvenuta. Prendiamo nota di tale messaggio, apriamo il Windasm e nella String Data Reference andiamo a ricercarlo. Una volta trovato apriamo IDA e portiamoci allo stesso offset. Si dovrebbe avere su schermo quanto segue:

0046CD52 call sub_4DA5AC
0046CD57 add esp, 8
0046CD5A lea edx, [ebp-328]
0046CD60 push edx
0046CD61 call sub_46CAE0			--> Questa call ci interessa
0046CD66 pop ecx
0046CD67 test al, al				--> Check flag: seriale immesso giusto o sbagliato...
0046CD69 jnz loc_46CE36				--> ..sbagliato? Non salta e visualizza messaggio di errore
0046CD6F push 48
0046CD71 push off_4FE40C
0046CD77 push offset aInvalidRegistr ; "Invalid registration. Please be sure    t"... 

0046CAE0 push ebp
0046CAE1 mov ebp, esp
0046CAE3 add esp, -28
0046CAE6 mov eax, [ebp+8]
0046CAE9 add eax, 50
0046CAEC push eax
0046CAED lea edx, [ebp+var_1C]
0046CAF0 push edx
0046CAF1 call sub_4DA5AC
0046CAF6 add esp, 8
0046CAF9 push dword ptr [ebp+8]
0046CAFC call sub_46C9DC			--> Altra call interessante...
0046CB01 pop ecx				--> Nuovo salto condizionato
0046CB02 test eax, eax
0046CB04 jnz short loc_46CB0A
0046CB06 xor eax, eax
0046CB08 jmp short loc_46CB25
 
0046CB0A loc_46CB0A: ; CODE XREF: sub_46CAE0+24j   
0046CB0A mov edx, [ebp+8]
0046CB0D add edx, 50
0046CB10 push edx
0046CB11 lea ecx, [ebp-28]
0046CB14 push ecx
0046CB15 call sub_4DA560			--> Call di comparazione seriale
0046CB1A add esp, 8
0046CB1D test eax, eax				--> Test di confronto che controlla il flag zero x l'istruzione successiva		
0046CB1F setz al    				--> Qui al viene settato a 0 o a 1 se il nostro seriale è sbagliato o corretto
0046CB22 and eax, 1							
0046CB25 loc_46CB25: ; CODE XREF: sub_46CAE0+28j   
0046CB25 mov esp, ebp
0046CB27 pop ebp
0046CB28 retn	

Ok veniamo alle spiegazioni:	in questo punto il seriale corretto è già stato calcolato dal programma che provvede a farne una 
comparazione (di 4 caratteri x volta) con quello immesso. Se tutto và come deve il test eax, eax all'indirizzo 0046CB1D abilita
il flag zero che fà si che il setz al non azzeri al ma lo imposti ad uno. Pertanto è qui che dobbiamo intervenire noi: è qui che il 
programma sia durante la fase di calcolo seriale che all'avvio controlla che tutto vada x il verso giusto, e se al rimane impostato a 0 
ci dirà sempre che non è registrato. Pertanto togliamo il setz al e al suo posto mettiamoci un bel mov al, 1 (lo potete fare usando Hiew
ma BADATE BENE che mentre il setz al occupa 3 bit e il mov al, 1 ne occupa solo 2, pertanto dovrete noppare (opcode 90h) il bite successivo):

setz al 	opcode --> 0F94C0
mov al, 1 	opcode --> B001 (digitare 90 (nop) nell'istruzione seguente)

Cosi' adesso potrete registrarvi con qualsiasi nome / seriale, e oltre alla nag di registrazione sarà sparito anche il tasto register nel menù
' Options '.						 																				

Parte Seconda: Serial Fishing

Bene, il target è stato patchato, ma se invece di patcharlo ci calcolassimo il seriale esatto?

Dunque, ritorniamo alla call che precede il messaggio di errore (0046CD61) ed entriamoci dentro,portandoci alla call all'indirizzo 0046CAFC.
Entriamo dentro anche a questae ci troviamo davanti al seguente codice:

0046C9DC push ebp

0046C9DD mov ebp, esp
0046C9DF add esp, 0FFFFFFECh
0046C9E2 push ebx
0046C9E3 xor eax, eax --> Azzeramento eax
0046C9E5 mov [ebp-8], eax     --> Azzera la locazione [ebp-8]      
0046C9E8 xor edx, edx --> Azzeramento edx
0046C9EA mov [ebp-12], edx --> Azzera la locazione [ebp-12]
0046C9ED xor ecx, ecx --> Azzeramento ecx
0046C9EF mov [ebp-10], ecx --> Azzera la locazione [ebp-10]
0046C9F2 push [ebp+8] --> Mette nello stack il primo nome inserito
0046C9F5 call sub_4DA5DC --> Usciti dalla call si ha in eax il numero di caratteri 
del primo nome inserito mentre ecx punta all'indirizzo che contiene il primo nome stesso


0046C9FA pop     ecx
0046C9FB mov     [ebp-4], eax --> Copia in [ebp-4] il numero di caratteri del primo nome
0046C9FE cmp     dword ptr [ebp-4], 0 --> Guarda se sono diversi da 0
0046CA02 jnz     short loc_46CA1B --> Se si salta e prosegue
0046CA04 xor     eax, eax
0046CA06 jmp     loc_46CAD9 --> Altrimenti salta e porta al messaggio d'errore
 
0046CA0B loc_46CA0B: ; CODE XREF: sub_46C9DC+48j
0046CA0B mov     edx, [ebp-4] --> Copia il edx il numero di caratteri del nome
0046CA0E mov     ecx, [ebp+8] --> In ecx viene copiata la locazione in cui si trova il primo nome
0046CA11 movsx   eax, byte ptr [ecx+edx] --> Viene messo in eax l'ultimo carattere del primo nome inserito..
0046CA15 add     eax, [ebp-4] --> .. e gli viene aggiunto il valore di [ebp-4]
0046CA18 add     [ebp-8], eax --> il risultato viene poi copiato in questa locazione (importante!!! C1)

0046CA1B loc_46CA1B: ; CODE XREF: sub_46C9DC+26j
0046CA1B mov     edx, [ebp-4]
0046CA1E add     dword ptr [ebp-4], -1  --> il valore di [ebp-4] viene decrementato di 1
0046CA22 test    edx, edx --> controlla se edx = 0
0046CA24 jnz     short loc_46CA0B --> Se non lo è torna sopra e ricomincia il ciclo...
0046CA26 mov     ecx, [ebp+8] --> una volta terminato, mette in ecx la locazione in cui è contenuto il secondo nome  
0046CA29 add     ecx, 25 --> vi somma 25 ( ora ecx punta al secondo nome)
0046CA2C push    ecx
0046CA2D call sub_4DA5DC
0046CA32 pop     ecx
0046CA33 mov     [ebp-4], eax --> eax al termine della call sopra contiene il # di caratteri del secondo nome
0046CA36 cmp     dword ptr [ebp-4], 0 --> se il secondo nome non è nullo
0046CA3A jnz     short loc_46CA54 --> salta e prosegue altrimenti prosegue e porta al messaggio d'errore
0046CA3C xor     eax, eax
0046CA3E jmp     loc_46CAD9

0046CA43 loc_46CA43: ; CODE XREF: sub_46C9DC+81j
0046CA43 mov     edx, [ebp-4] --> Copia il edx il numero di caratteri del nome
0046CA46 mov     ecx, [ebp+8] --> In ecx viene copiata la locazione in cui si trova il secondo nome
0046CA49 movsx   eax, byte ptr [ecx+edx+25] --> Viene messo in eax l'ultimo carattere del secondo nome inserito..
0046CA4E add     eax, [ebp-4] --> .. e gli viene aggiunto il valore di [ebp-4]
0046CA51 add     [ebp-12], eax --> il risultato viene poi copiato in questa locazione (importante!!! C2)
 
0046CA54 loc_46CA54: ; CODE XREF: sub_46C9DC+5Ej
0046CA54 mov     edx, [ebp-4]
0046CA57 add     dword ptr [ebp-4], -1 --> il valore di [ebp-4] viene decrementato di 1
0046CA5B test    edx, edx --> controlla se edx = 0
0046CA5D jnz     short loc_46CA43 --> Se non lo è torna sopra e ricomincia il ciclo...
0046CA5F push    dword ptr [ebp+8]
0046CA62 call sub_4DA5DC --> Al termine della call eax contiene il # di caratteri del primo nome..
0046CA67 pop     ecx
0046CA68 mov     ebx, eax --> ..che viene copiato in ebx
0046CA6A mov     eax, [ebp+8] --> eax nuovamente punta all'indirizzo del primo nome
0046CA6D add     eax, 25 --> ora eax punta all'indirizzo del secondo nome
0046CA70 push    eax
0046CA71 call sub_4DA5DC --> Al termine della call eax contiene il # di caratteri del secondo nome..
0046CA76 pop     ecx
0046CA77 add     ebx, eax --> ..che viene copiato in ebx (quindi ebx = numero caratteri primo nome + secondo nome)
0046CA79 mov     [ebp-4], ebx --> Questo numero viene copiato in [ebp-4]
0046CA7C imul    edx, [ebp-4], 6000 --> Moltiplica [ebp-4] x 6000 e mette il risultato in edx
0046CA83 add     edx, [ebp-8] --> Vi aggiunge C1
0046CA86 imul    ecx, edx, 6000 --> Moltiplica edx x 6000 e mette il risultato in ecx
0046CA8C add     ecx, [ebp-12] --> Vi aggiunge C2
0046CA8F mov     [ebp-20], ecx --> Mette il risultato ottenuto in questa locazione
0046CA92 cmp     dword ptr [ebp-20], 0 --> Se uguale a 0 salta, altrimenti procede
0046CA96 jz      short loc_46CAC9
 
0046CA98 loc_46CA98: ; CODE XREF: sub_46C9DC+EBj
0046CA98 mov     eax, [ebp-20] --> In eax il risultato del calcolo precedente
0046CA9B mov     ecx, 26 --> Copia in ecx il valore decimale 26 (N.B. COPIA, non aggiunge)
0046CAA0 xor     edx, edx --> Azzera edx
0046CAA2 div     ecx --> Operazione DIV su ecx

DIV - Divide
        Usage:  DIV     src
        Modifies flags: (AF,CF,OF,PF,SF,ZF undefined)
        Unsigned binary division of accumulator by source.  If the source
        divisor is a byte value then AX is divided by "src" and the quotient
        is placed in AL and the remainder in AH.  If source operand is a word
        value, then DX:AX is divided by "src" and the quotient is stored in AX
        and the remainder in DX.

In questo caso eax viene diviso x cl, il risultato viene messo in eax , il resto in dl.

0046CAA4 add     dl, 65 --> Al resto (messo in dl) ottenuto dalla divisione, viene sommato 65  
0046CAA7 mov     eax, [ebp-16] --> In eax viene messo il valore di [ebp-16] che è 0
0046CAAA mov     ecx, [ebp+8]
0046CAAD mov     [ecx+eax+50], dl --> dl viene copiato il questa locazione
0046CAB1 inc     dword ptr [ebp-16] --> [ebp-16] viene incrementato
0046CAB4 mov     ecx, 26 --> Nuovamente ecx contiene 26 (1Ah)
0046CAB9 mov     eax, [ebp-20] --> In eax il valore di [ebp-20]
0046CABC xor     edx, edx --> Azzera edx
0046CABE div     ecx --> Un'altra divisione, con stesso procedimento
0046CAC0 mov     [ebp-20], eax --> Copia in [ebp-20], eax (modificato dalla divisione precedente)
0046CAC3 cmp     dword ptr [ebp-20], 0 --> Controlla se [ebp-20] è = 0..
0046CAC7 jnz     short loc_46CA98 --> se si procede, altrimenti riprende il ciclo
 
0046CAC9 loc_46CAC9: ; CODE XREF: sub_46C9DC+BAj
0046CAC9 mov     eax, [ebp-16]
0046CACC mov     edx, [ebp+8]
0046CACF mov     byte ptr [edx+eax+50], 0
0046CAD4 mov     eax, 1
 
0046CAD9 loc_46CAD9: ; CODE XREF: sub_46C9DC+2Aj
0046CAD9 pop     ebx
0046CADA mov     esp, ebp
0046CADC pop     ebp
0046CADD retn --> Ritorna a 0046CB01

Dunque, vi chiederete il perchè delle due scritte in rosso.. ebbene ogni volta che il ciclo passa sopra l'indirizzo 

della prima scritta, calcola il nuovo carattere (o numero) 
che compone il seriale corretto (add dl, 65) mentre nel secondo indirizzo (che corrisponde alla seconda scritta 

in rosso) non fà altro che copiarlo in una locazione ben precisa
(mov [ecx+eax+50], dl) che ovviamente punterà, ad ogni "giro di boa", ad un indirizzo superiore di 1, in modo

 da dare alla fine del ciclo il seriale per intero. (Kiaro no? :) )  
Vediamo dunque, per onor di cronaca cosa succede dopo il return, ci troviamo esattamente qui:

0046CB01 pop     ecx
0046CB02 test    eax, eax --> Nuovo controllo per abilitare o meno il flag zero
0046CB04 jnz     short loc_46CB0A --> Seriale giusto? Non salta, altrimenti salta e porta all'errore
0046CB06 xor     eax, eax --> Se nn salta azzera eax e salta sotto
0046CB08 jmp     short loc_46CB25

0046CB0A loc_46CB0A: ; CODE XREF: sub_46CAE0+24j
0046CB0A mov     edx, [ebp+8]
0046CB0D add     edx, 50 --> Ora edx punta al seriale corretto
0046CB10 push    edx --> Che viene messo nello stack
0046CB11 lea     ecx, [ebp-28] --> In ecx il seriale (password) immesso da noi
0046CB14 push    ecx --> Anche questo nello stack
0046CB15 call    sub_4DA560 --> E qui c'è la call in qui vengono confrontati carattere x carattere i due seriali (corretto e non), entrateci e dateci un'occhiata  
0046CB1A add     esp, 8
0046CB1D test    eax, eax    \
0046CB1F setz    al | --> Questo punto lo conosciamo già..
0046CB22 and     eax, 1           /
 
...

Arrivati sin qui, ci starebbe bene un bel codice asm per il key gen... bè se lo sapete fare buon 

divertimento, il sottoscritto non è ancora in grado di farlo purtroppo :(.
Vabè non si può avere tutto :)
Alla prossima, BYEZ

P.S. Dove il goldwave salva le informazioni relative alla registrazione? Bè a voi il divertimento 

(filemonitor stà nella lista tools per questo :) ).

                                                                                                                 ParadoxEvil

OK siamo giunti ai saluti: un saluto al tutta #crack-it in particolare a Spin0, il Què (bè visto che mi uppa il tute mi sembra d'obbligo :3 ), Yado, Phobos, AndreaGeddon, +Malattia,
ALor, Jhones, PPinker (ma dove sei finito??) Kriosman, Il-Bieco ( :D), Dibbellas, Ded, NIKDH, Nerds, 

Along3x, CaptZero, Zer0Byte ecc.. ecc.. ecc... (non mi ricordo tuttiiiii) 

Quanto è stato detto in questo tutorial è puramente a scopo informativo e senza nessuna intenzione a fini di lucro.Se siete interessati all' appplicazione o gioco trattato in questa pagina siete pregati di comprarlo o pagare i relativi costi all'autore o a chi per esso.Tutto quanto detto non ha valore se usato per scopi illegali o comunque che ledano privatamente e/o pubblicamente l'autore o gli autori dell'applicativo descritto nel presente tutorial.Noi reversiamo solo a scopo didattico e non con fini illegali.