Zoom Icon

Corso UIC Avanzato 02 Ritz

From UIC Archive

Corso UIC Avanzato 02 Ritz

Contents


Corso UIC Avanzato 02 Ritz
Author: Ritz
Email: Email
Website: Home page
Date: 15/09/1999 (dd/mm/yyyy)
Level: Working brain required
Language: Italian Flag Italian.gif
Comments:



Tools


Link e Riferimenti

Questo è il Corsi UIC Avanzati n°02 disponibile alla pagina Corsi per Studenti


Introduzione

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

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


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

                                               // delnome (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????)

BEGGAR OFF 1

Jump at Addresses:

004012EB(C), :004012FF(C) 004012A2 push 00000010

Possible StringData Ref from Data Obj // "No! No! No! E poi Noooooo!!!" 004012A4 push 004020DF

Possible StringData Ref from Data Obj // "Serial sbagliato ;(" 004012A9 push 004020C3 004012AE push 00000000

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 :))

BEGGAR ON

Jump at Addresses:

004012FB(C), :00401301(U) 00401303 push 00000020

Possible StringData Ref from Data Obj ->"Ce l'hai fatta!!!" 00401305 push 00402057

Possible StringData Ref from Data Obj ->"Chiave indovinata...Complimenti!!!" 0040130A push 0040209C 0040130F push 00000000

Reference To: USER32.MessageBoxA, Ord:0000h

00401311 Call 004013DD // beggar on (hahahaha come sono

                             // spiritoso... :)))

00401316 jmp 00401156


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

BEGGAR OFF 2

Jump at Address:

0040120D(C) 00401371 push 00000030

Possible StringData Ref from Data Obj ->"Ehmmmmm!!! No!" 00401373 push 0040208D

Possible StringData Ref from Data Obj ->"W" 00401378 push 0040213B 0040137D push 00000000

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


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

I documenti qui pubblicati sono da considerarsi pubblici e liberamente distribuibili, a patto che se ne citi la fonte di provenienza. Tutti i documenti presenti su queste pagine sono stati scritti esclusivamente a scopo di ricerca, nessuna di queste analisi è stata fatta per fini commerciali, o dietro alcun tipo di compenso. I documenti pubblicati presentano delle analisi puramente teoriche della struttura di un programma, in nessun caso il software è stato realmente disassemblato o modificato; ogni corrispondenza presente tra i documenti pubblicati e le istruzioni del software oggetto dell'analisi, è da ritenersi puramente casuale. Tutti i documenti vengono inviati in forma anonima ed automaticamente pubblicati, i diritti di tali opere appartengono esclusivamente al firmatario del documento (se presente), in nessun caso il gestore di questo sito, o del server su cui risiede, può essere ritenuto responsabile dei contenuti qui presenti, oltretutto il gestore del sito non è in grado di risalire all'identità del mittente dei documenti. Tutti i documenti ed i file di questo sito non presentano alcun tipo di garanzia, pertanto ne è sconsigliata a tutti la lettura o l'esecuzione, lo staff non si assume alcuna responsabilità per quanto riguarda l'uso improprio di tali documenti e/o file, è doveroso aggiungere che ogni riferimento a fatti cose o persone è da considerarsi PURAMENTE casuale. Tutti coloro che potrebbero ritenersi moralmente offesi dai contenuti di queste pagine, sono tenuti ad uscire immediatamente da questo sito.

Vogliamo inoltre ricordare che il Reverse Engineering è uno strumento tecnologico di grande potenza ed importanza, senza di esso non sarebbe possibile creare antivirus, scoprire funzioni malevole e non dichiarate all'interno di un programma di pubblico utilizzo. Non sarebbe possibile scoprire, in assenza di un sistema sicuro per il controllo dell'integrità, se il "tal" programma è realmente quello che l'utente ha scelto di installare ed eseguire, né sarebbe possibile continuare lo sviluppo di quei programmi (o l'utilizzo di quelle periferiche) ritenuti obsoleti e non più supportati dalle fonti ufficiali.