Non si deve fare altro che trovare il serial... facile no?

Crackme 6
Risolviamo il 6° corso della UIC

Written by Sandokan

A differenza del 5° corso qui' c'è un solo seriale. Dopo aver trovato la routine la si deve studiare...

Soft Ice 4.0

Wdasm32 (per stamparmi il codice e averlo a portata di mano, a voi non serve :)

Be, credo che ormai lo sappiate tutti http://quequero.cjb.net e seguite i link alla sezione lezioni.

Richiesta di un seriale... come i programmi veri!

Gli obbiettivi che il caro Que ci ha imposto sono:

1) Trovare il serial esatto :) senza patchare il programma :(

        2) Scrivere un tutorial dettagliato sulla routine di crittazzione e check del serial

3) Eliminare tutti i bug di Winzoz (magari lo potessimo fare... :) AHAHAHAHAHAHAH NdQue

Eccocci quà con il 6° corso. Dato che questo è il mio primo tutorial, vorrei scrivere due righe di presentazione... spero che Que non si inkazzi. Bene, io mi sono iscritto alla UIC circa un mese fa (!!!) e prima di allora per me un file EXE era solo un file fatto in C, Pascal, ecc..Compilato. Ora ho scoperto che non è così, o non solo. Quello che voglio dire è che ciò che so (sul cracking naturalmente :) l'ho imparato in questo periodo, quindi sono un mega newbies e questo tutorial è sicuramente pieno di caxxate. Meno male che c'è Que che le segna e non vi fa confondere. Bene... detto questo, iniziamo!

 

Allora, appena avviato il programma ci compare una bella finestrella di Que che ci dice che il codice è di 16 caratteri. Infatti se proviamo a metterne di meno, il programma si blocca (poi mi sono accorto che in realtà il programma entra in un ciclo molto più lungo del normale che, non so se dipenda dalla velocità della CPU, ma sul mio K6 500 ci ha messo circa un minuto, poi mi è comparsa la solita messagebox di errore). Hihihihihihih pensa che io per fare questi test ho dovuto overclockare il mio povero mendocino fino alle orecchie.....Ahahahahahaha :) NdQue Allora clickiamo su Ok ed inseriamo un codice a caso di 16 caratteri. Poi un bel ^D e un BPX GETWINDOWTEXTA. F5 e Register, vediamo che il fidato sice poppa sullo schermo. Fin qui' tutto chiaro? Spero di si. Premendo F11 per uscire dalla call arriviamo qui':

:00401268  mov eax, dword ptr [004020CC]   ---   Noi arriviamo qui'...

Steppiamo (F10) fino a

:004012DF call 004012E9   ---   ...e veniamo qua'!

Se steppiamo ancora arriviamo ad un ExitProcess... vi suggerisce qualcosa? Spero di si... infatti succede tutto in questa call, la crittazzione del codice inserito ed il confronto con quello giusto. Dopo in base al risultato viene visualizzata la messagebox  di congratulazioni (401457) o quella di errore (40148B). Dopo di ciò si ritorna dalla call e si va al famoso ExitProcess (anche se a quanto ho visto in caso di errore si va ad un altro ExitProcess). Da buon newbies direi: e perchè non mettere un bel jmp da un messaggio all'altro? Eh eh eh... sarebbe bello, ma Que si inkazza... aaaaaaaaaahhhhhhhhhhh....Hihihihihihi sarà che sono pigro e non mi andava di scrollare in su la pagina per capire dove stava la label? :)))) NdQue la tentazione è troppo forte! Lo faccio, devo patchare! Ora che ci penso serve per capire la routine, dato che i confronti sono un casino... bene, ecco il codice (non andate a cercarlo, ci arriveremo dopo):

:00401409 mov eax, dword ptr [004020CC]
:0040140E cmp eax, 0C185C58   ---   Questo è il primo dei quattro confronti
:00401413 jne 0040147D             ---   Mentre questo è il primo dei quattro jmp al messaggio di errore
********
:00401419 mov eax, dword ptr [004020D0]
:0040141E cmp eax, 55F2600F
:00401423 jne 0040147D
********
:00401429 mov eax, dword ptr [004020D4]
:0040142E cmp eax, 35CE68B2
:00401433 jne 0040147D
********
:00401439 mov eax, dword ptr [004020D8]
:0040143E cmp eax, 1F3EECFA
:00401443 jne 0040147D
********
:00401449 push 00000020   ---   Se si arriva quà viene visualizzato il messaggio di congratulazioni

(al posto degli asterischi ci sono quattro nop che ho tolto per guadagnare spazio...)

Allora, come vi dicevo cercando di patchare abbiamo la possibilità di vedere che dopo tutte le varie crittazzioni il codice viene confrontato in quattro parti diverse. Per patchare abbiamo due possibilità: o noppiamo tutti i jne, o sostituiamo il primo con un jmp 401449. In entrambi i casi compare la messagebox di congratulazioni... fate voi. Comunque adesso torniamo a ciò che stavamo facendo... studiamo sta benedetta routine e leviamoci l'impiccio! (Da questo punto in poi il Tutorial diventa un campo minato... quante caxxate scriverò? Il computer di Que resisterà all'invasione di errori provocata da questo file? Tutta la UIC resta col fiato sospeso... :) Beh, comunque, ripartiamo da dove eravamo arrivati quando sice è poppato...

:00401268 mov eax, dword ptr [004020CC]   ---   Mette in eax tutto il codice (su questi mov non sono sicurissimo;)
:0040126D imul eax, 93572678    ---   Questi quattro imul dovrebbero effettuare delle moltiplicazioni
:00401273 mov ebx, dword ptr [004020D0]   ---   Mette in ebx il codice a partire dal 5° carattere
:00401279 imul ebx, 26547305
:0040127F mov ecx, dword ptr [004020D4]   ---   Mette in ecx il codice a partire dal 9° carattere
:00401285 imul ecx, 37569814
:0040128B mov edx, dword ptr [004020D8]   ---   Mette in edx il codice a partire dal 13° carattere
:00401291 imul edx, 89653715
:00401297 add eax, ebx   ---   Qui' somma
:00401299 add eax, ecx   ---   tutti i
:0040129B add eax, edx   ---   risultati
:0040129D push eax         ---   e li salva
:0040129E mov dword ptr [0040145D], eax   ---   Mette il risultato alla locazione 40145D
:004012A3 xor eax, eax   ---   Azzera eax? A che serve??? Non si sa mai....meglio azzerare sempre :) NdQue
:004012A5 mov eax, dword ptr [004020CC]   ---   Idem come sopra, carica il serial
:004012AA add eax, dword ptr [004020D0]   ---   ci somma la seconda parte (vedi sempre sopra)
:004012B0 mov dword ptr [00401461], eax   ---   e salva il risultato a 401461
:004012B5 mov eax, dword ptr [004020D4]   ---   Prende la terza parte
:004012BA add eax, dword ptr [004020D8]   ---   la somma alla quarta
:004012C0 mov dword ptr [00401475], eax   ---   e mette il risultato a 401475
:004012C5 mov eax, dword ptr [00401461]   ---   Prende il primo risultato
:004012CA dec eax   ---   e lo decrementa
:004012CB mov ebx, dword ptr [00401475]   ---   Prende pure il secondo
:004012D1 dec dword ptr [00401475]   ---   lo decrementa, ma a quanto pare non in ebx
:004012D7 imul eax, ebx   ---   Li moltiplica? In ASM l'istruzione IMUL significa: "Vai alla pasticceria" :) NdQue
:004012DA mov dword ptr [00401479], eax   ---   e ne salva il risultato alla locazione 401479
:004012DF call 004012E9   ---   Questa è la famosa call di cui parlavamo prima... vediamola!

(ricorda sempre che al posto degli asterischi ci sono quattro nop che ho tolto per guadagnare spazio...) I nop ce li mette il compilatore per non far incasinare il processore......Io ce li toglierei :) NdQue

:004012E9 cmp eax, FFFFFFFF   ---   Confronta eax con FFFFFFFF
:004012EC jg 004012F4   ---   Se è maggiore salta...
********
:004012F2 neg eax ---  altrimenti ne fa un complemento a due (poi Que ci spiega cos'è :) Hihih moltiplica eax *-1 :) NdQue
:004012F4 mov ecx, 00000014   ---   ...qua', e mette in ecx 14h
:004012F9 cdq   ---   Questo fa una conversione da double a quad (anche questo poi ce lo spiega) Grgrgrgrgrgrrg NdQue
:004012FA idiv ecx   ---   Divide il contenuto dell'accumulatore (eax?) per ecx e salva il risultato sempre nell'acc.
:004012FC mov ebx, dword ptr [004020CC]   ---   Salva il serial in ebx
:00401302 imul ecx, ebx   ---   e lo moltiplica per ecx
:00401305 mov ecx, dword ptr [004020D4]   ---   Carica la "terza parte" del serial in ecx (???)
:0040130B imul ecx, ecx   ---   e la moltiplica... per ecx (??????? o Que, ma che stai a fa?) Matematica spicciola NdQue
:0040130E dec eax   ---   Decrementa eax
:0040130F rol dword ptr [004020CC], 05   ---   Ruota i bit
:00401316 ror dword ptr [004020D4], 04   ---   Idem
:0040131D test eax, eax   ---   Se eax vale zero
:0040131F jne 004012FC   ---   salta su (questo è il ciclo che vi fa aspettare una sacco se mettete meno di 16 car.)
:00401321 cmp dword ptr [00401479], FFFFFFFF   ---   Confronta un valore salvato prima (ricordate?) con FFFFFFFF
:00401328 jg 00401334   ---   Se è maggiore salta...
********
:0040132E neg dword ptr [00401479]   ---   altrimenti ne fa un complemento a due
:00401334 sub dword ptr [00401479], 0321CCFA   ---   ...qua', e sottrae dalla locazione il valore 231CCFA
:0040133E cmp dword ptr [00401479], FFFFFFFF   ---   Rifà la stessa cosa di prima
:00401345 jg 00401351
********
:0040134B neg dword ptr [00401479]
:00401351 call 00401357   ---   Qui' finisce sta benedetta call... ma prima ce n'è un'altra! Vediamola...
:00401356 ret

:00401357 mov eax, dword ptr [004020CC]   ---   Al solito legge il serial
:0040135C call 004013FA   ---   Fa delle operazioni su eax
:00401361 call 004013D9   ---   Fa operazioni su ebx, ma poi ci mette dentro il valore di eax (???)
:00401366 sub dword ptr [004020CC], ebx   ---   Sottrae dal primo serial il valore di ebx
:0040136C mov eax, dword ptr [004020CC]   ---   e carica il risultato in eax
:00401371 mov dword ptr [00401465], eax   ---   Poi salva eax alla locazione 401465
:00401376 mov eax, dword ptr [004020D0]   ---   In base ai calcoli di prima... questa è la seconda parte del serial
:0040137B call 004013FA   ---   Queste due call sono sempre uguali (quattro chiamate)
:00401380 call 004013D9
:00401385 sub dword ptr [004020D0], ebx   ---   Anche le istruzioni sono uguali, cambia la parte di serial interessata
:0040138B mov eax, dword ptr [004020D0]
:00401390 mov dword ptr [00401469], eax
:00401395 mov eax, dword ptr [004020D4]
:0040139A call 004013FA
:0040139F call 004013D9
:004013A4 sub dword ptr [004020D4], ebx
:004013AA mov eax, dword ptr [004020D4]
:004013AF mov dword ptr [0040146D], eax
:004013B4 mov eax, dword ptr [004020D8]
:004013B9 call 004013FA
:004013BE call 004013D9
:004013C3 sub dword ptr [004020D8], ebx
:004013C9 mov eax, dword ptr [004020D8]
:004013CE mov dword ptr [00401471], eax
:004013D3 call 00401409   ---   Un'altra call... dentro la call. Qui' ci sono i confronti che abbiamo visto patchando.
:004013D8 ret

Ok, l'algoritmo è finito. Non vi sto a copiare le call dei due messaggi perché non c'entrano niente con l'algoritmo che ci interessa. Comunque vi ho già detto gli indirizzi, se volete andate a guardarle. In fondo l'algoritmo non era poi così difficile, da questo punto di vista il 5° corso era molto più tosto (d'altronde, se ho fatto io il tutorial, poteva essere difficile?); la cosa difficile era trovare il seriale, ma secondo quello che vedo (...e quello che so:) è impossibile risalire al codice, si dovrebbe prima di tutto beccarlo ai vari indirizzi del confronto, e ricostruirlo rifacendo al contrario tutto l'algoritmo. Non ci crederai, eppure anche risalendo al contrario sarebbe impossibile riottenere il seriale.....Strano eh? :) NdQue Quindi l'unico modo è PATCHARE! (lo sapevo che alla fine sarebbe servito :) Inoltre mi sono accorto che ci sono un sacco di istruzioni inutili, tipo dati salvati e mai più riletti, ecc.... Leggendo le varie mail della ML si parlava di Brute Forcing, ma è comunque un metodo indipendente dall'algoritmo (...vero?), praticamente si provano tutte le possibili combinazioni... mah, un giorno Que ci spiegherà! E poi più guardo sto crackme e più mi sento preso per il culo... perché "bugged crackme"? Perché nella finestra dove ci sono le due e-mail di Que sembra che ci sia un'altra scritta in basso che non si vede? (!?!) Grrrrr come perchè bugged? Semplice l'ho fatto a mezzanotte del 2000 quindi ho rischiato di vedermi il computer di esplodere in faccia.....e poi bugged perchè era affetto dal bug del 2000 :) NdQue Comunque, guardando i confronti nell'ultima call, vediamo che alla fine le quattro "parti" di serial esatto vengono confrontate con le quattro parti da noi inserite: quindi possiamo riassumere il tutto copiando solo le istruzioni che agiscono sulle locazioni di memoria che ci interessano. Facciamo un po' di ordine (ma che sto a fa?):

:00401268 mov eax, dword ptr [004020CC]    ---   Queste sono le quattro locazioni (sono 16 byte consecutivi)
:00401273 mov ebx, dword ptr [004020D0]
:0040127F mov ecx, dword ptr [004020D4]
:0040128B mov edx, dword ptr [004020D8]

:0040130F rol dword ptr [004020CC], 05   ---   Queste istruzioni ruotano i bit. Notate che vengono fatte solo su 2 parti
:00401316 ror dword ptr [004020D4], 04   ---   del seriale e che sono dentro un ciclo (quello che vi fa aspettare un poco :)

:00401357 mov eax, dword ptr [004020CC]   ---   Queste istruzioni vengono fatte quattro volte, una volta per ogni
:0040135C call 004013FA   ---   parte del serial, dentro le due call vengono fatte delle operazioni su eax e ebx
:00401361 call 004013D9
:00401366 sub dword ptr [004020CC], ebx   ---   E poi il tutto viene salvato di nuovo sulla locazione

Bene, sostanzialmente le istruzioni sono queste (spero... altrimenti ho perso tutto sto tempo per niente :). Come vedete non sono poi molte, ma per risalire al codice originale si deve fare tanto di quel casino che si fa prima a riscrivere il programma da capo (e comunque io non lo saprei fare). Per capirci facciamo un esempio facile facile:

inserendo come codice 16 "1" (1111111111111111) le quattro parti di seriale sono formate tutte da "1"

al momento del confronto invece, se guardiamo il contenuto delle locazioni (digitate ?eax), abbiamo dei codici supercrittati:

locazione      contenuto        serial esatto

4020CC    3980128979    0202923096

4020D0     3733201865    1441947663

4020D4     3733201865    0902719666

4020D8     3733201865    0524217594

Ok, questa volta abbiamo davvero finito...

Sono commosso... ho fatto il mio primo Tutorial... spero che non faccia troppo schifo ;)                                                          Di cosa tratterà il prossimo corso? Bho... aspettiamo.

                                                                                            Sandokan

Vorrei ringraziare innanzitutto Focus(!!!), che mi ha fatto scoprire la UIC. Poi Quequero per averla fatta. Poi tutti quelli che ci lavorano per migliorarla. Un "in bocca al lupo" particolare a tutti i newbies (come me): STUDIATE CHE CE LA FARETE!!! Saluti a tutta la ML che nonostante tutto il bordello che mi fa nell'Outlook mi tiene compagnia! CIAUZ A TUTTI!!!!!!!!!!!!!!!! Dimenticavo... ringrazio mio padre per avermi aperto la porta dell'informatica con il mitico COMMODORE 64 (!) e saluto il mio fratellino, proponendomi di farlo crescere a forza di vitamina A...ssembly!

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.

Capitoooooooo????? Bhè credo di si ;))))

 

 

UIC's page of reverse engineering, scegli dove andare:

Home   Anonimato   Assembly    CrackMe   ContactMe   Forum       
    Iscrizione   Lezioni    Links   NewBies   News   Playstation        
  Tools   Tutorial   Search   UIC Faq

UIC