Tutto iniziò verso la fine di ottobre sulla ML si iniziò../Tools.html a parlare di Tarantula. Un comune programma come tutti gli altri.

Tarantula 1.99
(Analizziamo dettagliatamente l'algoritmo che genera la Key)
Written by GR!SU'

Cercheremo insieme l'algoritmo e lo analizzeremo passo passo fino a trovare la chiave di registrazione adatta al nostro nome, se seguirete tutti i passaggi vi accorgerete che è semplicissimo. ...........Si dice sempre così..........dopo !!!???

SoftIce 3.2x

W32dasm 8.9x

http://www.indian-sites.com/nostrumindia/download.htm

Non sapevo neppure che esisteva, prima che lo avessero presentato in ML, comunque è un Editor HTML come tanti altri, non sò dirvi però se migliore o peggiore degli altri. Richiede un Name ed una Key per essere registrato.

Iniziamo questa nuova avventura......!!!! : -)

Tutto iniziò verso la fine di ottobre, quando in ML fu proposto "Tarantula" è precisamente con queste parole : Ciao, ho per le mani un editor Html tale "Tarantula 1.99", scaricabile qui http://www.indian-sites.com/nostrumindia/download.htm Il fatto è che all'entrata viene richiesto il solito serial number, in più c'è un time-limit di 30 g. Se provo a mettere qualche bpx, a parte che softice non poppa, in softice mi appare una scritta "Areyoulookingforsomething?....", deve esserci qualche anti-debug. Quello che è strano è che nella finestra in cui si inserisce il serialnum. non c'è un tasto per confermare quello che si è digitato, o meglio c'è un "Register Now" ma è inattivo. Fù così che iniziò la telenovela o Soap-opera intitolata "Tarantula".

Passavano i giorni e si susseguivano i messaggi, (curiosità, sono arrivati oltre 50 messaggi in ML) gli aiuti e le varie soluzioni, tutte però impostate sulla possibilità di Patchare il programma, nessuno però tentava di reversarlo. Pensai allora di scaricare anche io questo Target per tentare appunto di reversarlo, trovare cioè quello che il programma richiede e quindi darglielo, sinceramente è questo quello che io personalmente preferisco fare, lasciando la Patch come ultima soluzione.

Installo quindi il programma, ed inizio la solita esplorazione dello stesso per cercare di reperire il maggior numero di informazioni possibili che potrebbero essere di aiuto nel lavoro che andavo ad iniziare, tra queste trovo nell' Help la foto dell'Indiano autore di questo programma, andatela a vedere, vi verrà immediatamente voglia di continuare con la lettua di questo tutorial, io infatti è grazie a questa foto che ho continuato ed in seguito finito felicemente questo lavoro. Nel frattempo in ML si è iniziato a creare un gruppo di lavoro che è andato man mano crescendo, si è detto anche che :..è uno dei programmi, forse più tosti che abbia mai visto..Dall' esame del programma e dagli aiuti in MLsi ottengono tutte queste informazioni che ora vado ad elencare:

1) Il programma non registrato inserisce una scritta "not registered" nell' Htlm.

2) All' avvio cerca una chiave RegKey.Key, questo si può vedere usando FileMonitor.
3) Ha un antidebug.

4) Il file in cui incrementa i giorni è tarhelp.buk , se gli cambiamo l' attributo in sola lettura il programma parte anche dopo la scadenza ma da un messaggio di errore e ci dice che siamo al primo giorno di valutazione, funziona correttamente

5) Per attivare il tasto "Register Now" occorre digitare nel campo del numero seriale il trattino "-"

6) Il numero deve essere composto da 13 cifre più naturalmente il trattino

7) In HKEY_CLASSES_ROOT\regfile\TrackRegistryActiveX e HKEY_CLASSES_ROOT\regfile\TrackRegistryOCX
è contenuta la data del primo avvio

8) In HKEY_CURRENT_USER\Software\Nostrum India\Tarantula\Setup vengono salvati tutti i dati della registrazione.

9) Il programma fa un crc check che significa Cyclic Redundancy Code Check e ci dà quindi un

messaggio di errore se modifichiamo qualcosa nel codice

10) Il programma confronta il Name da noi inserito con "Nell Lang e poi con Alton G. Arndell " questa black-list si trova in c:\windows\ntahl.dat

 

Bene adesso facciamo finta di non conoscere tutte queste notizie e cominciamo dall'inizio.

Lanciamo il Prg. inseriamo in Name: GR!SU' ed in Key 123456, notiamo subito che il tasto "Register Now" non è attivo quindi è ovvio pensare che si attiverà solamente a Key esatta e che quindi il controllo viene effettuato in tempo reale mentre si inseriscono le cifre quindi l'unico sistema per entrare in Sice sembrerebbe quello di usare Hmemcpy, facciamo quindi Ctrl-D e settiamo Bpx Hmemcpy, invio e poi F5 per uscire. Inseriamo quindi un'altra cifra ed eccoci in Sice nella funzione Hmemcpy facciamo F5 una volta e poi iniziamo a steppare F10 finchè torniamo nel codice di Tarantula e precisamente qui:

:004292C9 mov dword ptr [esi+0C], eax ......................siamo qui
:004292CC jmp 004292D7

Continuiamo a steppare F10 finchè non arriviamo a questo punto

:004D9904 mov edx, dword ptr [ebp-04] ......................muove in Edx l'offset della locazione contenente la nostra Key
:004D9907 mov eax, 004D995C.....................................muove in Eax l'offset della locazione contenente il trattino 2D
:004D990C call 004042A8.............................................controlla la presenza del trattino
:004D9911 test eax, eax .................................................in Eax troviamo il numero n° di cifre che abbiamo inserito prima del trattino + il trattino, cioè se abbiamo inserito 1234-567 troveremo che Eax=05 ( quattro cifre + il trattino = a cinque)
:004D9913 jle 004D9924...............................................salta se Eax è zero, cioè se non è presente il trattino Eax=00

Se invertiamo il suscritto salto il pulsante Register Now viene attivato, risulta quindi evidente che la Call precedente ad esso effettua il controllo della presenza del trattino visto anche che ad essa vengono passati gli offset contenenti la Key ed il simbolo "-" 2D (facciamo quindi su di essa F8 se vogliamo capire come avviene questo controllo) ed inoltre dopo il salto abbiamo la routine che abilita il pulsante.

:004D9915 mov dl, 01
:004D9917 mov eax, dword ptr [ebx+000001F0]
:004D991D call 00426EF0.............................................routine che abilita il pulsante Register Now

Abbiamo quindi capito che nella nostra Key ci deve essere il trattino, disabilitiamo quindi tutti i Bpx ed usciamo da Sice. Inseriamo il Name ed una Key con il trattino ad esempio 1234-56 e premiamo "Register Now" per vedere come si comporta il programma e quindi capire come attaccarlo. Niente di niente, non mi da nessun messaggio di errore ed il programma rimane sempre Unregistered. Anche in questo caso quindi entriamo in Sice e proviamo con Bpx Hmemcpy usciamo e premiamo il nostro pulsante popperemo immediatamente in Sice, iniziamo a steppare, F10 fino a:

:004D8D44 mov eax, dword ptr [ebp-14].........................muove in Eax l'offset della locazione contenente la nostra Key
:004D8D47 call 00403FC0..............................................conta il numero dei caratteri della Key trattino compreso e lo mette in Eax
:004D8D4C cmp eax, 0000000C.....................................confronta Eax con 12
:004D8D4F jge 004D8D6D.............................................salta se Eax è maggiore o uguale a 12
|

:004D8D7B mov eax, dword ptr [ebp-14].........................muove in Eax l'offset della locazione contenente la nostra Key
:004D8D7E call 00403FC0..............................................conta il numero dei caratteri della Key trattino compreso e lo mette in Eax
:004D8D83 cmp eax, 0000000E.....................................compare Eax con 14
:004D8D86 jle 004D8DA4.............................................salta se Eax è minore o uguale a 14

Questo significa che la Key deve essere composta da minimo12 caratteri trattino compreso e massimo 14 non sappiamo però ancora di quanti deve essere effettivamente usciamo ed immettiamo i nostri 12 caratteri 1234567-8901, premiamo il pulsante "Register Now", ed ecco che compare una message box "Registration problem", benissimo abbiamo fatto già qualche piccolo passo. Adesso la prima cosa che ci viene in mente e di mettere un Bpx sulla MessageBox , ci proviamo ma con esito negativo, optiamo quindi per il classico e sempre attuale Bpx Hmemcpy. Ora una volta in Sice iniziamo a steppare fino a che non entriamo nel codice di Tarantula, dopo di chè disabilitiamo il Bpx Hmemcpy e continuiamo a steppare facendo attenzione al codice fino a che ci butta fuori, il tratto di codice quindi che ci interessa è quello precedente a questo evento, ed è proprio qui quindi che possiamo fermarci prima che ci butti fuori:

:004D9086 mov eax, dword ptr [ebp-18]........................muove in Eax l'offset della locazione contenente il nostro Name
:004D9089 pop edx.........................................................in Edx troviamo l'offset della locazione contenente la nostra Key
:004D908A call 0054F944..............................................CALL INCRIMINATA qui facciamo F8
:004D908F cmp eax, 00000009......................................controlla se Eax è uguale a 09
:004D9092 jg 004D90B4
:004D9094 je 004D919E.................................................se Eax è uguale a 09 salta a Registration OK

Ora non andremo ad esaminare il codice che segue il salto (se vi interessa fatelo voi), ma se volete provate ad invertirlo oppure mettete in Eax il valore 09 vedrete che nel Box dove avete inserito la Key comparirà la scritta Registration OK, il programma si avvierà è risulterà registrato, ma al successivo riavvio richiederà nuovamente i dati, da questo possiamo dedurre che la Routine incriminata e quindi da esaminare è quella che viene chiamata a :004D908A, facciamo F8 e ci troveremo qui:

:0054F944 push ebp
:0054F945 mov ebp, esp

continuiamo a steppare fino a:
|
:0054F9B3 mov eax, dword ptr [ebp-04]...........................muove in Eax l'offset della locazione contenente il nostro Name
:0054F9B6 mov edx, 0054FD14.......................................muove in Eax l'offset della locazione contenente Nell Lang
:0054F9BB call 004040D0................................................confronta il nostro Name con Nell Lang
:0054F9C0 je 0054FCB5 .................................................salta a "Registration problem "se i nomi sono uguali
:0054F9C6 mov eax, dword ptr [ebp-04]..........................muove in Eax l'offset della locazione contenente il nostro Name
:0054F9C9 mov edx, 0054FD28......................................muove in Edx l'offset della locazione contenente Alton G. Arndell
:0054F9CE call 004040D0................................................confronta il nostro Name con Alton G. Arndell
:0054F9D3 je 0054FCB5..................................................salta a "Registration problem " se i nomi sono uguali"
:0054F9D9 cmp dword ptr [00575174], 0069238F
:0054F9E3 jne 0054FCB5
:0054F9E9 mov eax, dword ptr [ebp-04]...........................muove in Eax l'offset della locazione contenente il nostro Name
:0054F9EC call 00403FC0................................................conta il numero dei caratteri del Name e lo mette in Eax
:0054F9F1 cmp eax, 0000001F.........................................confronta Eax con 31
:0054F9F4 jg 0054FA0C...................................................salta se il numero dei caratteri che compongono il Name è > 31

NB. Questo significa quindi che il Name deve essere composto al massimo da 31 caratteri
| Continuiamo a steppare....
|
:0054FA22 mov eax, dword ptr [ebp-08]............................muove in Eax l'offset della locazione contenente la nostra Key
:0054FA25 call 00403FC0..................................................conta il numero dei caratteri della Key e lo mette in Eax
:0054FA2A cmp eax, 0000000D.........................................compare Eax con 14
:0054FA2D jg 0054FA45...................................................salta se il numero dei caratteri che compongono la Key è > 14
|
:0054FA40 cmp dword ptr [ebx], 0000000E.......................in Ebx c'e il numero dei caratteri della Key
:0054FA43 jne 0054FA31.........................................salta se il numero dei caratteri che compongono la Key è diverso di 14

Ora sappiamo che la nostra Key deve essere composta da 14 caratteri compreso il trattino.Usciamo quindi da Sice e reimmettiamo il nostro Name ed una Key di 14 caratteri es. 1234567890-123 ripetiamo tutte le operazioni precedenti fino a ritornare di nuovo a :0054FA43 , qui continuiamo a steppare......(esaminate se volete tutto il codice che segue il salto, perchè molto interessante ed utile per apprendere come vengono effettuati alcuni controlli, ma non essenziale per gli scopi di questo Tut.)... fino ad arrivare a:

:0054FC02 call 00402EFC..................................................riporta in Eax le cifre 7890 della nostra Key non in Hex ma nella stessa forma che le abbiamo inserite nel Box cioè in Eax avremo Eax=00007890

Dopo questa routine inizia il nostro algoritmo, fate quindi molta attenzione ai passaggi..................PS. Inserite in Name :GR!SU' e in KEY:1234567890-123 perchè gli esempi che farò saranno basati su questa combinazione, naturalmente dopo potrete sostituire il Name con uno differente.

:0054FC07 mov edi, eax
:0054FC09 mov dword ptr [ebx], 00000020.....................muove nella locazione puntata da Ebx il valore 20h (31 dec che sarebbe il numero massimo di caratteri da cui può essere composto il Name)

1) qui inizia la prima parte della generazione della Key

:0054FC0F mov ecx, dword ptr [ebx]................................muove in ecx 20h
:0054FC11 dec ecx...........................................................decrementa Ecx
:0054FC12 mov eax, dword ptr [ebp-14]..........................muove in Eax le prime quattro cifre della Key (1234) in forma esadecimale cioè in Eax=31323334
:0054FC15 shr eax, cl.......................................................shifta a sinistra eax di 20h al primo loop, 19h al secondo e così via
:0054FC17 and eax, 00000001
:0054FC1A mov edx, dword ptr [ebp-04].........................muove in Edx l'offset della locazione contenente il nostro Name
:0054FC1D mov ecx, dword ptr [ebx]...............................muove in Ecx il valore 20h
:0054FC1F mov dl, byte ptr [edx+ecx-01]........................muove in dl un carattere alla volta del Name (partendo dall'ultimo (il 31°) fino ad arrivare al primo, alla fine del ciclo)

PS. Se il nostro Name Es. GR!SU' (47 52 21 53 55 27) non occupa tutti e 31 i caratteri possibili , tutti gli altri sono degli spazi quindi 20h questo significa che in dl avremo partendo dall'ultimo(31°) 20 , (30°) 20, (29°) 20..................(6°) 27, (5°) 55, (4°) 53, (3°) 21, (2°) 52, (1°) 47

:0054FC23 xor dl, byte ptr [ebp+eax-1D]........................fa Xor tra dl (uno dei nostri caratteri) e la 5° e 6°cifra della Key
:0054FC27 xor eax, eax...................................................azzera il registro
:0054FC29 mov al, dl.......................................................muove in al il risutato dello xor
:0054FC2B imul dword ptr [ebx]......................................moltiplica Eax per il contenuto di Ebx che in valore decrescente per ogni ciclo va da 20h a 00h (da 31 a 00)
:0054FC2D add esi, eax..................................................alla fine del ciclo in Esi abbiamo il risultato dell'algoritmo tra il nostro Name e le prime sei cifre dalla Key che nel nostro caso è 2FC8
:0054FC2F dec dword ptr [ebx]......................................decrementa Ebx
:0054FC31 cmp dword ptr [ebx], 00000000....................compare Ebx con 00
:0054FC34 jne 0054FC0F...............................................salta e ripete il ciclo finchè Ebx non diventa zero

2) qui inizia la seconda parte

:0054FC36 mov dword ptr [00575174], 0069238F
:0054FC40 mov eax, dword ptr [ebp-14]........................muove in Eax le prime quattro cifre della Key (1234) in forma esadecimale cioè in Eax=31323334
:0054FC43 add eax, edi..................................................addiziona ad Eax il contenuto di Edi (in Edi abbiamo 7890)
:0054FC45 xor edx, edx..................................................azzera il registro
:0054FC47 mov dl, byte ptr [ebp-1D].............................muove in dl la cifra 5 della nostra Key in esadecimale 35h
:0054FC4A add eax, edx................................................addiziona ad Eax Edx (nella parte bassa di Edx, in dl abbiamo 35)
:0054FC4C xor edx, edx.................................................azzera il registro
:0054FC4E mov dl, byte ptr [ebp-1C].............................muove in dl la cifra 6 della nostra Key in esadecimale 36h.
:0054FC51 add eax, edx.................................................addiziona ad Eax Edx(nella parte bassa di Edx, in dl abbiamo 36)
:0054FC53 sub eax, dword ptr [ebp-10]..........................in Ebp-10 abbiamo in esadecimale la cifra intera che abbiamo dopo il trattino nella nostra Key, per intera intendo 123 che in esadecimale è 7Bh
:0054FC56 mov ecx, 00000064.......................................muove in Ecx il valore 64h (100 dec.)
:0054FC5B cdq.................................................................prepara una divisione
:0054FC5C idiv ecx.........................................................effettua la divisione tra Eax ed Ecx e mette il risultato in Eax ed il resto in Edx che nel nostro caso è 08h

Fate molta attenzione all'istruzione precedente è importantissima anzi fondamentale, praticamente affinchè l'algoritmo prosegua bisogna che la divisione non debba avere resto, in Edx dovremmo quindi avere Edx=00000000

:0054FC5E mov eax, edx..............................................muove in Eax il resto della divisione Edx
:0054FC60 test al, al.....................................................controlla se c'è resto
:0054FC62 je 0054FC6B.............................................salta se non c'è resto cioè se al=00
:0054FC64 mov esi, 00000007
:0054FC69 jmp 0054FC94..........................................salta verso "Registration problem"

Per ora fermiamoci quì.......Come facciamo ad avere zero come risultato della divisione, ...semplice (questa affermazione posso farla solo adesso). Arrivato a questo punto decisi di sospendere la lavorazione di questa telenovela, intanto in ML si continuava a parlare di Tarantula, alcuni passi erano stati fatti, finalmente si era arrivati ad una Patch definitiva ma nessuno ancora aveva realizzato un Reversing completo, decisi allora prendendola come sfida tra me e l'Indiano di riprendere il lavoro anche perchè era quasi fatta mancava appunto quella piccola intuizione che a volte fà la differenza, ripresi il lavoro rivedendomi ed analizzandomi approfonditamente tutto il codice fino ad allora esaminato, ma niente di niente, eppure la soluzione era lì che mi guardava :-))) hihihi!!!!, il problema era questo:

Guardate attentamente il codice che segue il punto dove ci eravamo fermati..

:0054FC6B cmp edi, esi....................................confronta le cifre 7890 (in Edi) con il risultato dell'algoritmo precedente 2FC8 (in Esi)
:0054FC6D jne 0054FC8F...............................salta se sono diversi altrimenti continua verso "Registration OK"
- la parte successiva del codice non ci interessa più.

Il Cmp fondamentale di tutto l'algoritmo sembrerebbe questo e far si che Edi ed Esi siano uguali è molto semplice, l'istruzione infatti confronta il risultato della prima parte dell'algoritmo 2FC8 con le cifre poste rispettivamente al 7° 8° 9° e 10° posto, nel nostro caso 7890 quindi basta semplicemente mettere al loro posto il risultato appunto dell'algoritmo (effettuato tra il nosto Name e le prime 6 cifre della Key) così come lo troviamo in Edi, la nostra Key sarà quindi 1234562FC8-123 naturalmente supponendo che come Name abbiamo GR!SU' . Fatto questo se invertiamo il salto (:0054FC62) che controlla se la divisione ha o non ha resto, arriveremo al Cmp Edi, Esi e salteremo a "Registration OK", ma il programma, una volta riavviato sarà sempre Unregistered, questo significa che quella divisione è fondamentale, dobbiamo far si quindi che il risultato sia intero e non abbia resto. Come fare?...... Ritorniamo indietro alla seconda parte dell'algoritmo, cosa possiamo fare affinchè la divisione non mi dia resto, sapendo che il divisore (64h) è fisso, è semplice bisogna creare un dividendo adatto ed il sistema più semplice sarebbe quello di vedere in Edx quanto vale il resto, nel nostro caso è 08h e sottrarlo al valore inserito nelle posizioni 7890 quindi 2FC8-08=2FC0 inseriamo quindi 1234562FC0-123 sempre con Name GR!SU', vedremo quindi che il risultato della divisione sarà 00 ed arriveremo al famoso compare che ovviamente però ora non sarà più uguale, perchè il risultato della prima parte dell'algoritmo è sempre lo stesso 2FC8 ma noi nella Key lo abbiamo sostituito con 2FC0 per far si che la divisione non avesse resto, quindi siamo riusciti a soddisfare una condizione ma non l'altra, da questo sembra quindi che sia quasi impossibile soddisfarle tutte e due contemporaneamente.............Ma evidentemente mi sfuggiva qualche cosa.....che fine hanno fatto i tre numeri dopo il trattino????? Ecco quindi che siamo arrivati alla soluzione dell'algoritmo ed alla fine di questa telenovela. Ecco cosa succede:
-Domanda: Nell' esempio precedente, come avevamo fatto a far risultare il resto della divisione uguale a 00 ???
-Risposta: Sottraendo praticamente dal dividendo il resto.
Ed è proprio questo che avviene all'offset :0054FC53 sub eax, dword ptr [ebp-10], in ebp-10 troviamo il valore esadecimale del numero composto dalle tre cifre dopo il trattino nel nostro caso 123=7Bh , avevo già notato ovviamente questa riga di codice, non immaginavo però cosa fosse questo valore, pensavo fosse un valore fisso, infatti rimaneva sempre uguale, naturalmente perchè io inserivo sempre come ultime tre cifre 123. Arrivati a questo punto vi sarete penso chiesti perchè il trattino è posizionato in quel punto preciso, il ragionamento è semplice, dato che come divisore viene prelevato tutto l'intero numero che segue il trattino, ad esso non possono che seguire per forza di cose altro che tre numeri o al limite due oppure uno, ma non più di tre perchè sapendo che il numero di cifre della Key è 13 più il trattino, le prime sei insieme al nome generano le successive cifre precedenti il trattino che non possono essere meno di 4 ma che potrebbero essere anche 5 oppure 6 solo che dopo resterebbero meno cifre dopo il trattino e quindi sarebbe più difficile realizzare il numero da sottrarre che ci occorre, quindi preferiamo lasciare tre cifre dopo il trattino, abbiamo più possibilità. Il discorso è un pò ingarbugliato, ve lo spiego con un esempio. Usciamo da Sice ed inseriamo come Name sempre GR!SU' e come Key 1234562FC8-000, una volta arrivati al punto in cui effettua la divisione leggiamo in Edx il resto nel nostro caso 1Fh , è quindi questo il numero che dobbiamo mettere al posto dei tre zeri, naturalmente trasformato in decimale 1Fh=31, ed essendo le ultime cifre tre inseriremo 031 avremo quindi finalmente il risultato del nostro lavoro:

Name: GR!SU'

Key: 1234562FC8-031

In conclusione noi abbiamo la possibilità di scegliere non solo il nome, ma anche le prime sei cifre, è solo per facilità che ho scelto una serie di numeri in sequenza.

Spero di essere stato abbastanza chiaro, anche se effettivamente il tutto forse risulterà un pò ingarbugliato, ma se seguite attentamente tutti i miei esempi e passaggi vi accorgerete che effettivamente l'algoritmo è semplicissimo....; -)

Adesso possiamo finalmente dire che la telenovela "Tarantula" è completamente finita (anche se forse quanto leggerete questo tutorial sono convinto che non interesserà già più a nessuno), .........comunque .....alla fine............se proprio volete saperlo............Vissero tutti felici e contenti....!!!! ;-))

CiAo da GR!SU'.....alla prossima.!!!           

Ho cercato di portarvi passo passo alla decodifica dell'algoritmo, spero di esserci riuscito, voglio solo far notare quanto sia stato interessante e soddisfacente per me realizzare questo lavoro anche se il programma in questione non mi interessava, ma solo per spirito di sfida come ho già detto, verso l'autore ma più che altro verso me stesso, quindi penso sia molto formativo creare in ML queste possibilità, si crea in questo modo il gruppo, la voglia di lavorare insieme per raggiungere degli obbiettivi comuni e la sfida che è quella che ti fà andare avanti e perseguire tutti gli obbiettivi.

Ora non mi resta che, ovviamente, Ringraziare QUEQUERO per la sua grande disponibilità e la UIC tutta ed in rigoroso ordine casuale tutti quelli che mi hanno aiutato a progredire in questa nobile ARTE (anche se alcuni di loro forse non lo sanno).

Un dovuto e sentito ringraziamento va' all'amico Sator SSH per avermi iniziato a questa Nobile Arte.
+ORC mitico Neural_Noise, Scacco, CoRN2, ED!SON, raZZia, FROSTMAN, CbD, Qapla , +MaLattiA, along3x, Marcus, AloR, Xoanon, Int19, alt255 tutto il gruppo di RingZ3r0, tutti quelli che ho dimenticato ed anche quelli che non conosco.
Ringrazio inoltre tutta la ML e tutti quelli che hanno partecipato ogniuno a proprio modo a questa battaglia.

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:

Home   Anonimato   Assembly    ContactMe  CrackMe   Links   
NewBies   News   Forum   Lezioni  
Tools   Tutorial 

UIC