Esame2.html: UIC

	Esame UIC n° 2 (sniffamento serial)
15/09/1999	by "Ritz"
	UIC's Home Page	Published by Quequero
	Bravissimo anche ritz, complimenti anche perchè presenti sempre un magnifico form :), cmq non serve commentare ogni sngola istruzione :))
UIC's form	E-mail: Eclyps3@excite.com Ritz, 41793377, #crack-it	UIC's form
Difficoltà	(X)NewBies ( )Intermedio ( )Avanzato ( )Master

Mattina del 15 settembre, bel tempo, ore 9.52. Non penso di aver tempo per fare il keygen, anche perchè domani inizia la strafottutussima squola, di conseguenza cercherò di rendere questo tute quantomeno decente. Spero di riuscirci :-))).

Esame UIC n° 2 (sniffamento serial) Written by Ritz

Introduzione

Hi everybody!! Come va? Qui non troppo bene, causa imminente inizio nuovo anno scolastico ;((. Per il resto cmq tutto OK. Beh, come penso già sappaite in questo tute cercherò di spiegarvi il funzionamento dell'algoritmo che genera il seriale riguardante il 2° esame dell'UIC scritto dall'egregio pr... erm meglio di no.... scritto da Quequero ;)). Sarebbe inoltre necessario scrivere un keygen per tale proggy, ma quello penso proprio di non riuscire a farlo :((.

Tools usati

SoftIce 3.24 (lo so mi devo aggiornare...).
Wdasm 8.93 (non indispensabile, io l'ho usato solo per poter incollare le righe di codice).

URL o FTP del programma

http://quequero.cjb.net

Notizie sul programma

Questo programma è stato scritto apposta da Que per essere crackato, anzi no, meglio, reversato: bisogna studiarci l'algoritmo che genera il seriale partendo dal nome e di conseguenza farci un keygen.

Essay

PREMESSA: consiglio prima di tutto di disassemblare il file due.exe col Dasm, magari salvarlo in formato testo e poi guardarselo con un editor, o meglio ancora stamparsi la parte di codice interessata. In seguito ho deciso di inserire varie righe di codice per commentarle, ma cmq è meglio stamparsi tutto per una visualizzazione "cartacea" (wow sembro un libro :)))

OK gente, pronti 1 2 3 via!!!

Apriamo il programmillo in questione... ci comparirà una finestra (ma no!!!! davvero??) nella quale dovremo inserire un nome e un numero seriale, quest'ultimo naturalmente generato a partire dal nome stesso eheh :). Mettete un nome e un numero a caso. A meno che non abbiate un culo grande come 'na casa (ma in questo caso vi consiglio di lascar perdere il cracking/reversing: ditemi invece 6 numeri randomizzati compresi tra 1 e 90 ihihihi :))) vi comparirà una messagebox: "Serial sbagliato ;(". Se invece non iserite nulla, vi comparirà questo messaggio: "Wè, son mica scemo!!! :)". Vabbè... direte voi... che fare?? Dunque dunque, come sempre per prima cosa entriamo nel nostro amato Sice con CTRL+D e settiamo un bpx per intercettare qualche API. Per la precisione, mettiamo un bpx su GetWindowTextA. Chiudiamo il Sice e inseriamo nei 2 campi richiesti dati a caso in modo però da riempirli entrambi (sono ammessi al massimo 7 caratteri per il nome e 5 per il serial). Clicchiamo su "Register" e vedremo il Sice fare la sua comparsa, precisamente ci troveremo qui (riporto TUTTO il codice che ci sarà utile di seguito... alla fine commenterò un po'...):

* Referenced by a CALL at Address: |:004011DF | :004011F2       push 00000019 <-- max n° di caratteri :004011F4       push 0040219F <-- buffer per il nome :004011F9       push dword ptr [004020D7] * Reference To: USER32.GetWindowTextA, Ord:0000h | :004011FF       Call 004013B3 :00401204       xor ecx, ecx <-- attraccaggio (azzera ecx) :00401206       mov al, byte ptr [0040219F] <-- prende il primo carattere                                                  del nome e lo mette
:0040120B       test al, al <-- controlla se il 1° carattere c'è o no                                      in al :0040120D       je 00401371 <-- se non è stato inserito nulla jumpa ad una                                  beggar-off :00401213       xor eax, eax <-- azzera eax * Jump at Address: |:00401277(U) | :00401215       mov al, byte ptr [ecx+0040219F] <-- muove in al il 1° char                                         del nome (con ecx come contatore NdQue) :0040121B       test al, al <-- controlla se il nome è terminato :0040121D       je 00401279 <-- se sì salta, altrimenti continua   con la manipolazione del char :0040121F       xor al, cl <-- xora al con cl :00401221       mov edi, ecx <-- muove ecx in edi :00401223       mul edi   ; Hei Ritz, questa è doverosa da commentare NdQue :00401225       sub al, 25 <-- sottrae 25 da al :00401227       add al, cl <-- aggiunge il contenuto di cl ad al :00401229       xor al, byte ptr [ecx+00402000] <-- xora al con un byte                                                      preso da 402000 * Possible StringData Ref from Data Obj ->"77103798325" | :0040122F       mov edx, 00402193 <-- indirizzo spostato in edx :00401234       mov ebx, dword ptr [0040219F] <-- sposta 2 byte da 40219F                                                  a ebx :0040123A       xor ebx, edx <-- xora ebx con edx * Possible StringData Ref from Data Obj ->"34065479327" | :0040123C       mov edx, 00402183 <-- muove 402183 in edx... :00401241       xor ebx, edx <-- ...che viene xorato con ebx :00401243       add ebx, ecx <-- aggiunge il contenuto di ecx a ebx :00401245       add al, byte ptr [ecx+00402000] <-- aggiunge ad al un byte                                                      puntato da 402000 :0040124B       xor bl, byte ptr [ecx+00402000] <-- xora bl con lo stesso                                                      byte :00401251       shl al, 02 <-- moltiplica al per 4 :00401254       ror al, 04 <-- ruota 4 bit di al a destra :00401257       shr bl, 03 <-- divide bl per 3 Sicuro???? NdQue :) :0040125A       rol bl, 08 <-- ruota di 8 bit a sinistra bl :0040125D       xor bl, al <-- xora bl con al :0040125F       xor bl, byte ptr [00402002] <-- rixora bl con un byte puntato da 402002 :00401265       xor bl, cl <-- ririxora (e che palle... :) ) bl con cl :00401267       rol bl, 08 <-- esegue rol a sinistra di 8 bit :0040126A       add bl, al <-- aggiunge al a bl :0040126C       sub al, 05 <-- sottrae 5 da al :0040126E       sub bl, al <-- sottrae al da bl :00401270       mov byte ptr [ecx+0040218F], al <-- muove il 1° char del                            nome crittato in 402018F...Ma ti scordi le cose??? :) :00401276       inc ecx <-- incrementa il contatore :00401277       jmp 00401215 <-- jumpa all'inizio per cominciare con un nuovo char

* Jump at Address:
|:0040121D(C)
|
:00401279       xor ecx, ecx <-- azzera ecx

* Jump at Address:
|:004012A0(U)
|
:0040127B       mov al, byte ptr [ecx+0040218F] <-- muove il char del buffer visto sopra in al
:00401281       test al, al <-- da me al = 193 sempre
:00401283       je 00401331
:00401289       cmp al, 66 <-- controlla se al=66 (66 ASCII = f ma non penso che centri ;)) Io penso di si ;)
:0040128B       jg 0040131B <-- se al > 66 salta

* Jump at Address:
|:00401321(U)
|
:00401291       cmp al, 30 <-- confronta al con 30
:00401293       jl 00401326 <-- se al < 30 salta

* Jump at Address:
|:0040132C(U)
|
:00401299       inc ecx <-- incrementa il contatore
:0040129A       mov byte ptr [ecx+004021A7], al <-- muove 1 byte di al in                                                      un buffer
:004012A0       jmp 0040127B <-- jumpa (ma vaaaaaa????)

-----    * Jump at Addresses:
|        |:004012EB(C), :004012FF(C)
|        |
| B     :004012A2       push 00000010
| E
| G     * Possible StringData Ref from Data Obj ->"No! No! No! E poi Noooooo!!!"
| G     |
| A     :004012A4       push 004020DF
| R
|        * Possible StringData Ref from Data Obj ->"Serial sbagliato ;("
| O     |
| F     :004012A9       push 004020C3
| F     :004012AE       push 00000000

| 1     * Reference To: USER32.MessageBoxA, Ord:0000h
|        |
|        :004012B0        Call 004013DD <-- CALL della MessageBox
-----    :004012B5       jmp 00401156

* Jump at Addresses:
|:00401349(C), :00401361(U), :0040136C(U)
|
:004012BA       mov byte ptr [ecx+00402173], al <-- muove 1 byte di al in                                                      un buffer
:004012C0       mov byte ptr [ecx+00402174], ah <-- idem con ah
:004012C6       jmp 00401333 <-- se non sapete cosa fa, o siete sotto coca o siete idioti ;))

* Jump at Addresses:
|:0040133B(C), :00401343(C)
|
:004012C8       push 00000019 <-- max caratteri serial
:004012CA       push 004021A3 <-- buffer nome
:004012CF       push dword ptr [004020DB]

* Reference To: USER32.GetWindowTextA, Ord:0000h
|
:004012D5       Call 004013B3 <-- call dell'API
:004012DA       xor ecx, ecx   <-- azzera ecx (come sempre)
:004012DC       mov eax, dword ptr [ecx+004021A3] <-- e vabbè dai, muove 2              byte puntati da 4021a3 Orroreeeeee una dword sono 4 byte NdQue :)
:004012E2       mov ebx, dword ptr [ecx+004021A8] <-- idem                                                       4021A3 in eax
:004012E8       inc ecx <-- incrementa il contatore
:004012E9       cmp eax, ebx <-- *PUNTO IMPORTANTE* guardate un po' che                                  c'è nei 2 registri?!
:004012EB       jne 004012A2 <-- eax = ns. serial ebx = serial corretto:                                  salta se diversi
:004012ED       mov al, byte ptr [ecx+004021A3] <-- prende il 1° char del                                              ns. serial e lo mette in al
:004012F3       mov bl, byte ptr [ecx+004021A8] <-- stessa cosa col 1° del                                                  serial corretto (in bl)
:004012F9       test al, al <-- guarda se è finito il serial (supposizione...)
:004012FB       je 00401303 <-- se sì jumpa (v. s.)
:004012FD       cmp al, bl   <-- confronta i 2 primi chars
:004012FF       jne 004012A2 <-- se diversi jumpa
:00401301       jmp 00401303 <-- altrimenti jumpa lo stesso però da un'altra parte :))

* Jump at Addresses:
|:0040128B(C), :0040131F(C)
|
:0040131B       sub al, 12 <-- sottrae 12 da al
:0040131D       cmp al, 66 <-- confronta al con 66 (66=f ma non centra ihih so che rompo :))) C'entra e come se c'entra :)))
:0040131F       jg 0040131B <-- se al > 66 jumpa per minorizzarlo (neologismo...)
:00401321       jmp 00401291 <-- se invece no allora salta da un'altra parte

* Jump at Addresses:
|:00401293(C), :0040132A(C)
|
:00401326       add al, 18 <-- aggiunge 18 ad al
:00401328       cmp al, 30 <-- confronta al con 30
:0040132A       jl 00401326 <-- se al < 30 jumpa per minorizzarlo (altro neologismo...)
:0040132C       jmp 00401299 <-- indovinate un po? Bravi: xora 63$3%3 con 385H385#!!

* Jump at Address:
|:00401283(C)
|
:00401331       xor ecx, ecx <-- azzera ecx

* Jump at Addresses:
|:004012C6(U), :00401359(U)
|
:00401333       mov al, byte ptr [ecx+004021A7] <-- muove un byte dal buffer in al
:00401339       test al, al <-- confronto...
:0040133B       je 004012C8 <-- ... e salto!!!
:0040133D       mov ah, byte ptr [ecx+004021A8] <-- muove un byte da buffer ad ah
:00401343       je 004012C8
:00401345       cmp ah, al <-- confronta ah con al
:00401347       inc ecx
:00401348       inc edx
:00401349       jne 004012BA <-- jumpa se diversi
:0040134F       add al, 02 <-- aggiunge 2 ad al
:00401351       cmp al, 66 <-- lo confronta con 66
:00401353       jg 00401366 <-- e se al > 66 jumpa
:00401355       cmp al, 30 <-- altrimenti lo confronta con 30
:00401357       jl 0040135B <-- e se al < 30 jumpa
:00401359       jmp 00401333 <-- altrimenti continua...

{ RIFLESSIONE: e voi direte: "ma sto cazzo di Ritz non poteva dire "Se 66 < al < 30 jumpa, altrimenti no?" NOO!!! E perché? Perchè se al < 66 jumpa in un posto, se al > 30 IN UN ALTRO. Non penso sinceramente che l'abbiate pensato... scusatemi dell'interruzione... eheheh :))))

* Jump at Addresses:
|:00401357(C), :0040135F(C)
|
:0040135B       add al, 02 <-- aggiunge 2 ad al
:0040135D       cmp al, 30 <-- confronta al con 30
:0040135F       jl 0040135B <-- solito discorso... jumpa per                  maggiorizzarlo Neologismo???? :P
:00401361       jmp 004012BA <-- continua quando al è maggiorizzato

* Jump at Addresses:
|:00401353(C), :0040136A(C)
|
:00401366       sub al, 03 <-- substracta 3 da al
:00401368       cmp al, 66 <-- confronta al con 66
:0040136A       jg 00401366 <-- jumpa per minorizzarlo
:0040136C       jmp 004012BA <-- continua se minorizzato

-----    * Jump at Address:
|        |:0040120D(C)
|        |
| B     :00401371       push 00000030
| E
| G     * Possible StringData Ref from Data Obj ->"Ehmmmmm!!! No!"
| G     |
| A     :00401373       push 0040208D
| R
|        * Possible StringData Ref from Data Obj ->"W"
| O     |
| F     :00401378       push 0040213B
| F     :0040137D       push 00000000
|
| 2     * Reference To: USER32.MessageBoxA, Ord:0000h
|        |
|        :0040137F        Call 004013DD <-- CALL della MessageBoxA
-----    :00401384       jmp 00401156

........ CONTINUA (MA A NOI NON CE NE FREGA 'NA PIPPA) .........

AAAAAAAAAAAAAAAAAHHHHH!!!! (* esclamazione di sfinimento *)

Ciao gente!! Siete ancora qui? Non siete rincoglioniti dopo tutti 'sti commenti? Bene, io sì (almeno mi sono rincolgionito nello scriverli...), però non posso certo fermarmi qui con la spiegazione... di conseguenza aggiungerò altre 2 parole.

Dunkuez, come vedete il buffer per il nome è 40219F, quello del serial che inseriamo noi 4021A3, quelo del serial corretto 4021A8 (se fate d 4021A8 esso vi comparirà: sono le prime 4 cifre ASCII). Il tutto inizia con la lettura del nome: se non c'è il prog. salta l'esecuzione alla beggar-off ribattezzata da me "n° 2" (401371 per la precisione), altrimenti continua normalmente l'esecuzione prendendo 1 a 1 i caratteri del ns. nome e manipolandoli secondo la fantasia che Que aveva in quel momento (da 401215 a 401277), poi passa ad altri cazzeggi vari nei quali al diventa protagonista il quale deve essere minore di 66 ma maggiore di 30 - tra l'altro non so perchè :))) Ma come ancora non l'hai capito???? :) sarà una routine a caso ;))- Sacrilegiooooooooo, disperazioneeeeee noooooooooooooooo NdQue e alla fine arriva la seconda GetWindowTextA, quella del check seriale: vengono salvati i buffer dei rispettivi 2 serialz in eax ed ebx, i quali vengono poi confrontati (se fate ? ebx vedrete il serial giusto ribaltato e con ? eax il serial messo da voi ribaltato): se non sono uguali apparirà la beggar-off n° 1, altrimenti c'è un altro piccolo check che confronta i primi chars dei nomi - che non ho capito cmq a cosa cazzo serva... -, quindi se tutto è OK appare la mitica beggar on (non penso che il termine esista, se sì fatemelo sapere... :))).

NOTICILLA: il nome inserito non può essere più lungo di 4 chars, o meglio il prog. analizza, critta e considera solo i primi 4 chars del nome se questo è più lungo: gli altri non vengono nemmeno letti. Una prova viene data all'indirizzo 4012DC (infatti dword = 2 word = 4 byte = 4 caratteri), Due dword = 8 byte = 8 caratteri, hei ritz, ma se un byte è un byte, una word sono due byte, come fa una Dword cioè una doppia word ad essere lo stesso di due byte????: byte: 00
word: 0000: Dword: 00000000; byte: a; word: ab; dword: abcd; ok? NdQue
e ciò è dimostrabile anche nella pratica: io, avendo un nome di 4 lettere, se provo ad aggiungerci qualcosa e ad inserire lo stesso serial di "Ritz", ottengo la beggar-on (mi piace tropo chiamarla così... :))). Anche il serial sarà sempre e solo di 4 caratteri, ma ovviamente se noi ne inseriamo di più, allora sì che ci comparirà il messaggio d'errore...

OK raga penso di aver proprio finito... spero un casino di riuscire a fare il keygen, cosa però difficile :((. Mi auguro cmq di aver commentato in modo chiaro le righe di codice, di aver spiegato bene il check e magari che voi abbiate scoperto q.sa di nuovo riguardante l'ASM ;)). Sappiate ad ogni modo che io ho cercato di farlo nel migliore dei modi.

Ciauzzzzzzzzz a tutti!!!

Ritz

Note finali

Allora, la lista di persone che dovrei salutare e ringraziare sono come al solito un casino, quindi le metto tutte in rigoroso ordine random.

Saluto Quequero (ormai non serve nemmeno che metta i motivi... se state leggendo questo tute è soprattutto merito suo :)), +MaLaTTiA (disponibilissimo in IRC, soprattutto nel darmi un template per il keygen: grazie Mala ;)), BlackDruiD (il compagno di classe e forse la persona di #crack-it con cui parlo di più... :)), WhiteFly (anche se è da un po' che non lo vedo :(( ), Furb3T (sempre disponibile su IRC), xERHOD (per i consigli sulla programmazione ;)), TiN_MaN (ao la facciamo 'sta partita a Tetrinet??), [aLT255] (probabilmente colui col quale sono stato introdotto nel canale #crack-it nonchè un amico... ;)), iNX (anche se non lo vedo spesso... eheh :)), ^courier (per la grande simpatia nonchè disponibilità), T3X (ache lui molto disponibile), |_raul_|, Unlock, ZeroByte (per la chattata di mercoledì ;)), xOA, come sempre tutti quelli di #crack-it, i ringz3r0, e coloro che mi sono dimenticato di nominare (cazzo spero di averli detti tutti, se qualcuno si accorge di non esserci e vuole insultarmi mi scriva pure all'indirizzo sopra eheh). Saluto anche i BoT di #crack-it, che negli ultimi periodi sfortunatamente non sembrano godere di ottima salute. Viruz eh??! Noooo, la saga continua :) sotto sistemi *nix non esistono i viruz :) Ciao Noxia, ciao R|ngM4N!! Eheeeheheheheheh.

Un particolare saluto va anche a DFX, la cui povera bicicletta è all'ospedale per colpa mia ;(((.

Dalla mia laringe parte invece un incommensurabile fuck alla scuola che devo riiniziare (porka puttanaaaaaaa), e infine al virus che mi sta distruggendo il computer... cazzo mi stanno sparendo file... ciò mi insospettisce, meglio formattare, non ho nemmeno uno straccio di antivirus installato (idiota io in effeti :)))...

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 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.

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