Dunque dunque, at first ciao a tutti!! Che dire, in questo tute cercher� di spiegare la sprotezione di Dreamweaver 2 della Macromedia. Vi auguro quindi buona lettura (anche se penso che, date le condizioni dell'autore nel momento in cui questo tute � stato scritto, molti preferiranno crackarsi da soli il programma che leggere fino in fondo ;-)) )!!!

Dreamweaver 2 da trial a + infinito
(cracking misto non resisto ;) )
Written by Ritz

Beh, sappiate che la sprotezione del programma, anche se il tute penso verr� un po' lunghetto, non � per nulla ostica (altrimenti non sarei certo riuscito a farla!!). Per poterla attuare, per�, ci si deve avvalere dei tre tools per il cracking probabilmente pi� "classici" nonch� utilizzati: un debugger, un disassembler, un hex-editor. Quindi penso che cmq questo possa essere un utile "esercizo" per imparare a usare SoftIce, W32Dasm e Hiew. Dico bene Que? Dici bene :) NdQue

SoftIce 3.24 (Ancoraaaa?? Emb� s�, aho non mi sono ancora aggiornato) o sup.

Hiew 6.04 (V.S.) o un hex-editor a piacere

W32Dasm 8.93 o un disassembler (es. IDA)

Dunque, il sito della Macromedia � www.macromedia.com, penso che l� si possa trovare, cmq il file occupa circa 10 mega, quindi non vale la pena scaricarselo da Internet. Io ad esempio l'ho trovato su un paio di riviste informatiche. Se raspate bene tra le decine di CD di riviste che avete vi salter� fuori di sicuro!!

Il programma � un famosissimo editor HTML (col quale tra l'altro ho scritto questo tute ;) ).

La demo � valida per 30 giorni, dopodich� si suicida. Il proggy cmq pu� venir "comprato" (virgolette d'obbligo ;) ) e quindi registrato: se tutta questa procedura avviene regolarmente, esso sar� reso eterno.

Bene bene raga, siete interessati alla cosa? OK perfetto, non resta che andare ad agire. Installatevi il programma. Avviatelo. Vi apparir� una finestra con 3 opzioni disponibili: "Buy Now", "Try", "Cancel". Sussistendo la condizione acciocch� la quale (?!?!?) vogliamo comprare il software perch� ci piace, clicchiamo sul pulsante "Buy Now". Vi apparir� un'altra finestra. Ha inizio ora la...

-------------------------------------------------------------------------------------

PARTE UNO DEL TUTE

ACQUISTO DEL PROGRAMMA

-------------------------------------------------------------------------------------

Perfetto, iniziamo! Inserite tutti i dati che volete, naturalmente falsificate pure, quindi premete "Next". Bene, ora dovreste vedere un'altra finestrella in cui dovete decidere COSA comprare (assieme al proggy dovrebbe esserci anche la possibilit� di acquistare la guida... cmq non penso vi interessi): scegliete ci� che preferite, ed ecco che un'altra finestra appare ridente, e questa sar� gi� il primo ostacolo da superare. Infatti essa vi chiede una carta di credito, una data di scadenza riferita alla carta, un "Name on Card" che non so che cacchio sia ma non me ne frega nulla. Hihihi bh� � il nome del proprietario che si trova sulla carta di credito :) NdQue Se avete una carta di credito (cosa di cui io non sono in possesso) o ne avete fregata una, potete metterci i dati veri ;) (cosa che cmq sconsiglio), altrimenti vi consiglio di far tutto ci� (e qui inizia la spiegatio):

Scrivete numeri a caso come numero di carta di credito, nello spazio della expiration mettere una data del tipo mm/aa, io ho messo 12/99 (non siate plz cos� idioti da mettere 'na roba gi� scaduta OK??), quindi poppate nelGhiaccioMorbido con CTRL+D (che fooooooraaaaaa GhaiccioMorbido.... chiss� perch� l'hanno chiamato cos�...Giuro che oggi mentre tornavo a casa mi stavo interrogando sullo stesso quesito, chiss� perch�..NdQue) e mettete un bel bpx sull'API getdlgitemtexta (bpx getdlgitemtexta). Bene, fatto? OK, uscite dal Sice, confermate con "Next", e il Sice popper� felicemente in una DLL del programma: rsagnt32.dll. Premete in tutto 3 volte CTRL+D e quindi F11: vi troverete qui.

* Referenced by a CALL at Addresses:
|:1000A44A , :1000A49A
| |--------------------------------------------- INIZIO CALL DELLA LETTURA
:1000AA50 56 push esi
:1000AA51 8B742408 mov esi, dword ptr [esp+08]
:1000AA55 57 push edi

* Reference To: USER32.GetDlgItemTextA, Ord:00F5h
|
:1000AA56 mov edi, dword ptr [1003A5C8]
:1000AA5C push 00000018
:1000AA5E push 100302A0 <-- buffer

* Possible Reference to Dialog: DialogID_07D2, CONTROL_ID:006B, ""
|
:1000AA63 push 0000006B
:1000AA65 push esi
:1000AA66 call edi
:1000AA68 push 00000009 <-- 1� attraccaggio
:1000AA6A push 100302C0 <-- buffer

* Possible Reference to Dialog: DialogID_07D2, CONTROL_ID:006C, ""
|
:1000AA6F push 0000006C
:1000AA71 push esi
:1000AA72 call edi
:1000AA74 push 00000027 <-- 2� attraccaggio
:1000AA76 push 10030260 <-- buffer

* Possible Reference to Dialog: DialogID_07D2, CONTROL_ID:006D, ""
|
:1000AA7B push 0000006D
:1000AA7D push esi
:1000AA7E call edi
:1000AA80 pop edi <-- 3� attraccaggio (dove vi trovate)
:1000AA81 xor eax, eax <-- prepara eax
:1000AA83 pop esi
:1000AA84 ret

Se alla terza schermata del Sice iniziate a steppare con F8, dopo essere arrivati a 1000AA84 vi ritroverete qui:

* Reference To: USER32.PostMessageA, Ord:01B1h
|
:1000A43E Call dword ptr [1003A5BC]
:1000A444 jmp 1000A51A
:1000A449 push esi
:1000A44A call 1000AA50
:1000A44F add esp, 00000004 <-- eccovi qui
:1000A452 push esi
:1000A453 call 1000AAA0 <-- entriamoci con F8
:1000A458 add esp, 00000004
:1000A45B test eax, eax
:1000A45D je 1000A51A
:1000A463 push FFFFFFFF
:1000A465 push 00000000
:1000A467 push esi

Let's analyze: il RET di 1000AA84 naturalmente si riferisce alla CALL (situata a 1000A44A) che legge i valori inseriti da tastiera. Una volta che tutta tale lettura � avvenuta, bisogna passare al check: arrivati a 1000A44F, infatti, inizia la procedura di controllo, e precisamente, come si pu� facilmente notare, bisogna entrare nella CALL a 1000A453 per poter osservarla. Tracciatela quindi con F8 una volta arrivati l�. Ecco dove vi troverete:

* Referenced by a CALL at Address:
|:1000A453 <-- ma vaaaaa??
|
:1000AAA0 mov eax, dword ptr [10032B50] <-- sposta 4 char dal buffer a eax
:1000AAA5 push esi
:1000AAA6 test eax, eax <-- confronta
:1000AAA8 je 1000AB29 <-- Uguali? Salta!!
:1000AAAA mov eax, dword ptr [100302BC]
:1000AAAF cmp eax, 0000006F
:1000AAB2 je 1000AB29
:1000AAB4 cmp eax, 00000070
:1000AAB7 je 1000AB29
:1000AAB9 mov esi, dword ptr [esp+08]
:1000AABD push esi
:1000AABE call 1000AB30
:1000AAC3 add esp, 00000004
:1000AAC6 test eax, eax
:1000AAC8 je 1000AAE1

Osserviamo un po' adesso la situazione: a 1000AAA0 4 byte vengono spostati dal buffer a eax, quindi eax viene testato e, se l'esito � positivo, il programma salta, altrimenti continua nella procedura. Hum... secondo me conviene provare a farlo eseguire questo salto vero? Dunque, se il buffer contiene qualche dato allora il test a eax dovrebbe servire per vedere se i dati sono finiti, o se il buffer � vuoto NdQue Bene, steppate fino a 1000AAA8 e quindi scrivete "r fl z" (senza virgolette). Con questo comando dovreste sapere che si inverte il valore dello Zero Flag. In altre parole, quando avviene un test o un cmp, se i due valori confrontati sono uguali, esso viene settato a 1, altrimenti a 0. Con "r fl z" si cambia appunto questo valore invertendo quindi l'esito del jump. Infatti, dopo aver fatto ci� ed essere steppati dovreste arrivare qui:

* Jump at Addresses:
|:1000AAA8(C), :1000AAB2(C), :1000AAB7(C), :1000AB10(C)
|
:1000AB29 xor eax, eax
:1000AB2B pop esi
:1000AB2C ret

Che succede? Semplice, dopo il salto avvenuto eax viene azzerato e c'� il RITORNO dalla CALL che era incaricata del checking dei valori inseriti (quella a 1000A453). Steppati oltre 1000AB2C, infatti, vi ritroverete di nuovo a 1000A458 (vi rimetto il pezzo di codice con aggiunta la parte seguente):

* Reference To: USER32.PostMessageA, Ord:01B1h
|
:1000A43E Call dword ptr [1003A5BC]
:1000A444 jmp 1000A51A
:1000A449 push esi
:1000A44A call 1000AA50
:1000A44F add esp, 00000004 <-- eccovi qui
:1000A452 push esi
:1000A453 call 1000AAA0 <-- la CALL del checking
:1000A458 add esp, 00000004 <-- dove vi trovate ORA
:1000A45B test eax, eax
:1000A45D je 1000A51A
:1000A463 push FFFFFFFF
:1000A465 push 00000000
:1000A467 push esi

* Reference To: USER32.SetWindowLongA, Ord:021Bh
|
:1000A468 Call dword ptr [1003A5C4]
:1000A46E mov eax, 00000001
:1000A473 pop edi
:1000A474 pop esi
:1000A475 pop ebp
:1000A476 pop ebx
:1000A477 add esp, 00000050
:1000A47A ret 0010

Allora, siete adesso tornati al punto di prima. Che dire, come vedete poco dopo il punto dove ora vi trovate c'� un'API particolare, SetWindowLongA... tradotto "imposta la larghezza della finestra" (A � il solito codice a 32 bit) SetWindowLongA in genere si usa per cambiare lo stile di una finestra non per impostarne la larghezza :) NdQue... cazzo ma... sar� mica vero?? Arrivate fino a quella CALL con F8, entrate pure nel kernel se volete: non � uno scherzo!! Premente CTRL+D, et voil�, il primo ostacolo � superato!!

Bene raga, ora la prima parte � fatta, peccato che era anche la pi� facile ;). OK vi lascio 5 minuti di pausa... [zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz]

OK aho ora basta dorm� eh?!? Siete tornati in voi? Bene, allora ora nel programma dovreste trovarvi in una schermata dove potrete inserire dei commenti per i developers: scrivete un po' di insulti vari, quindi procedete; ora apparir� un'altra schermata con un riassunto di ci� che volete comprare... OK chi cazzo se ne frega, avanti sempre!! Altra schermata (eccheccacchiooo!!): scegliete il tipo di registrazione. Naturalmente io ho fatto by phone. Nextate ancora, e, boeing!!, ecco davanti a voi il secondo ostacolo fresco fresco. Vi verr� chiesto infatti un unlock code che, se inserito correttamente, determiner� la fine della procedura di acquisto (hihihihihihi tanto il bello viene dopo!!). OK scrivete un numero, poppate nel Sice, bpx sul getdlitemtexta, uscite dal Sice, premente OK o Register (ora non ricordo), e... crashhh!! No no, non vi si inkioda WinTroio, non vi preoccupate, bens� entrerete nel Sice. F11 per uscire dalla funzia e andare nella rsagnt32.dll, e quindi, eccovi qui:

* Reference To: USER32.GetDlgItemTextA, Ord:00F5h
|
:1000B856 Call dword ptr [1003A5C8]
:1000B85C mov edi, 1002C9C0
:1000B861 or ecx, FFFFFFFF
:1000B864 xor eax, eax
:1000B866 repnz
:1000B867 scasb
:1000B868 not ecx
:1000B86A dec ecx
:1000B86B cmp ecx, 0000000A <-- A=10, cio� lunghezza carattere
:1000B86E je 1000B8AB <-- lunghezza sbagliata? BEGGAR OFF!!
:1000B870 mov edx, dword ptr [10032CB4]

* Possible StringData Ref from Data Obj ->"Sorry, that unlocking code is "
->"not valid for this program."
|
:1000B876 push 10022A30 <-- BEGGAR OFF
:1000B87B mov word ptr [edx+04], ax
:1000B87F lea eax, dword ptr [esp+0C]
:1000B883 push eax
:1000B884 call 100152C0
:1000B889 add esp, 00000008
:1000B88C lea ecx, dword ptr [esp+08]
:1000B890 push 00000030

A meno che non siate gi� in stato di rincoglionimento totale, penso vi accorgiate che subito dopo il getwindowtexta c'� una messagebox che ci avverte che siamo dattilograficamente delle mezza seghe. Deve essere ASSOLUTAMENTE EVITATA, e le uniche possibilit� che avete sono di attivare il je a 1000B86E. Per far ci� potete:

A- Scrivere un codice di 10 caratteri nella finestra.

B- Invertire il flag del je a 1000B86E.

Per quanto riguarda il primo metodo, non vi sto a spiegare come fare perch� � troppo complicato ;)), per il secondo posso spenderci qualche parola. Allora, una volta arrivati a 1000B86E scrivete ancora "r fl z" se il codice da voi inserito NON � di 10 charz. Il mio consiglio � comunque quello di usare 10 caratteri NdQue Popperete quindi akk�:

* Jump at Address:
|:1000B86E(C)
|
:1000B8AB mov edx, dword ptr [10032CB4]
:1000B8B1 push 1002C9D0
:1000B8B6 add edx, 00000106
:1000B8BC push edx
:1000B8BD push 1002C9B0
:1000B8C2 call 1000BF20
:1000B8C7 add esp, 0000000C
:1000B8CA push 1002C9C0
:1000B8CF push 1002C9D0
:1000B8D4 call 10020420
:1000B8D9 add esp, 00000008
:1000B8DC test eax, eax
:1000B8DE jne 1000B93B
:1000B8E0 mov eax, dword ptr [10032CB4]
:1000B8E5 mov [eax+04], 0001
:1000B8EB mov ecx, dword ptr [10032CB4]
:1000B8F1 cmp word ptr [ecx+0000020C], 0002
:1000B8F9 jne 1000B930
:1000B8FB mov edx, dword ptr [10032CB8]
:1000B901 push 00000000
:1000B903 push 10011A60
:1000B908 push esi

* Possible StringData Ref from Data Obj ->"_SERDLGBOX"
|
:1000B909 push 1002294C
:1000B90E push edx

* Reference To: USER32.DialogBoxParamA, Ord:008Eh
|
:1000B90F Call dword ptr [1003A594]
:1000B915 test eax, eax
:1000B917 je 1000B930
:1000B919 mov eax, dword ptr [10032CB4]
:1000B91E mov [eax+04], 0000
:1000B924 or eax, FFFFFFFF
:1000B927 pop edi
:1000B928 pop esi
:1000B929 add esp, 00000100
:1000B92F ret

NON entrate assolutamente nelle CALL a 1000B8C2 e 1000B8D4: l'ho provato a fare io, per� a parte il fatto che non serve a nulla, ci si perde tra meandri di codice inutile ai nostri fini. Osservate invece 1000B8DC: un altro test di eax che se d� esiti negativi jumpa away... la stessa cosa a 1000B8F9. Osservate invece un'altra API di User32.dll: dialogboxparama. Cazzo NON � la messagebox di prima (bens� una nuova finestra), quindi... sussistendo il fatto che a parte 2 jne non c'� nulla che ci impedisce di entrarci, facciamolo!!! Steppate con F10 (per evitare le CALL nominate sopra), e noterete che i due jump sarebbero attivati se non cambiaste lo Zero Flag con un altro "r fl z". Arrivati rispettivamente a 1000B8DE e poi 1000B93B, quindi, scrivetelo. Il programma continua lineare la procedura e... una volta arrivati alla CALL del dialogboxparama (� la dialogbox di conferma), uscite dal Sice con CTRL+D. Evvai!!!! Appare un'altra finestra!!! Bene bene, questa � una finestra di conferma, quindi confermate!!! :)) Fatto. Complimenti, qui finisce la prima parte del tute: il programma � ufficialmente (?!) comprato. Yeahhhhhhh direte voi, noooooooo dico io!! Infatti ora si passa alla

-------------------------------------------------------------------------------------

 

PARTE DUE DEL TUTE

 

REGISTRAZIONE DEL PROGRAMMA

 

-------------------------------------------------------------------------------------

 

-----------------------------------------------------

Momento di riflessione: il programma � comprato, per� ci manca il serial number necessario alla registrazione. Voi vi chiederete... perch� il tute � stato diviso in 2 parti separate? In fondo � sempre di cracking che si tratta. S�, per� sono due cose diverse, in quanto con la prima parte TERMINA il riferimento alla DLL di prima per quanto riguarda l'acquisto, che viene dimenticato per sempre, e con la finestra di registrazione inizia una nuova parte forse pi� "classica" e che fa riferimento ad un file molto meno specifico: Dreamweaver.exe

-----------------------------------------------------

 

OK ora riprendiamo, aho siamo qui per lavor� o no??? Dopo qualche secondo dall'ultima conferma d'acquisto dovreste trovarvi in un punto che vi chiede nome, iniziali, cognome, societ�, indirizzo, telefono, e-mail, lavoro, stipendio, misura scarpe, altezza, gruppo sanguigno, altre 11-12 cosette e alla fine un serial number. A parte la battuta squallida su ci� che dovete inserire ;) scrivete quello che volete, e quindi fermatevi un secondo perch� dovreste aver notato una cosa. In basso nella finestra di registrazione c'� scritto testualmente "The serial number is printed on your Customer Support Card". Ora viene da pensare 'na roba: i programmatori della Macromedia sono un po' cretini anche loro, in quanto qui ci danno un grosso aiuto: infatti, ci comunicano gentilmente che il serial number valido NON � calcolato in base ai dati da noi inseriti, bens� si trova gi� da qualche parte nel proggy!!! ERGO, non ci sar� una marea di jump condizionali che determinano il da farsi, bens� il jump da cambiare sar� alla fine UNO solamente. Questo almeno in teoria, in quanto non ci � molto utile sapere che non troveremo una giungla di codice per andare tranquilli, bens� per STARE tranquilli una volta dentro. Infatti, la guingla c'� cmq, solo che almeno sappiamo che non calcola un cazzo in base al nome. Non so se mi capite, il ragionamanto forse � un po' contorto... Erhmmm ricordo una volta di aver crackato il DreamWeaver non ricordo che versione ma usava lo stesso metodo di protezione e ricordo anche che il seriale da inserire era scritto in caratterini ASCII non crittati proprio nel codice esadecimale NdQue

Vabb�, in ogni caso procediamo. Scrivete ci� che volete, mettete un bpx su getwindowtexta (non pi� getdlgitemtexta) e premete OK (nota: come conferma al fatto che l'unico valore che conta � il serial, noterete che il Sice poppa 5 volte ma SEMPRE nello stesso punto). Dopo che siete poppati l'ultima volta, premete F11 e vi ritroverete nel bel mezzo di mfc42.dll, ma cazzo se provate ad esaminare un po' il file anche semplicemente steppando vi accorgerete che � una cosa enorme...Mmmmm hei ritz dimmi na cosa, ma che in genere steppi pure dentro a kernel32.dll e dentro a user32.dll?......Scherzi a parte non devi steppare in questa dll perch� � come se andassi a steppare nel kernel, non sono dll proprietarie ma dll standard :) NdQue personalmente io ho quindi tentato di utilizzate il W32Dasm per vedere se si poteva trovare qualcosa di utile non in real-time, e mi sono disassemblato il file. Vi consiglio cmq di seguire il codice che di seguito riporter�, in quanto il file dreamweaver.exe occupa un casino e da me ci vogliono 30 minuti per disassemblarlo. Seguite quindi questo ragionamento.

Nella schermata di registrazione se mettete un codice sbagliato il programma vi dice che il serial non � corretto, ma al 5� tentativo appare un normale messagebox il quale ci avvisa che il programma terminer� ("Bad Serial number message, quitting"). E' proprio questo che sar� il nostro punto d'attacco. Una volta disassemblato l'eseguibile, infatti, andiamo a cercare sulle String Data References se troviamo qualcosa... diamo un'occhiata... hum hum... l'unica cosa utile sulla quale sembra si possa agire sembra proprio questa messagebox... vabb� facciamoci doppio click col topo e capiteremo esattamente qui nel codice (* zio kernel, ora per� ho un problema tecnico: cazzo il file Dreamweaver.exe disassemblato sono 80 milioni di caratteri... come cacchio faccio a visualizzarlo? Edit... nada, WordPad... troppo lento, cazzo prover� col Word... ci si risente tra un bel po' di minuti... scusate devo aspett� che Word finisca di caricare il file......................... ecchime qua, OK penso di essermi preso le righe giuste tra le 25000 pagine di testo ;) riprendiamo *); dicevo vi troverete precisamente hic:

 

* Jump at Address:
|:005B3ECE(C)
|
:005B400F lea ecx, dword ptr [ebp-14]

 

* Reference To: MFC42.Ordinal:021C, Ord:021Ch
|
:005B4012 Call 0081A630
:005B4017 mov [ebp-04], 12
:005B401B cmp dword ptr [ebp-18], 00000004
:005B401F jne 005B4030

 

* Possible StringData Ref from Data Obj ->"Bad Serial number message, quitting"
|
:005B4021 push 008C33BC
:005B4026 lea ecx, dword ptr [ebp-14]

Anche senza dover esser geni dell'ASM si capisce che c'� un salto condizionato che porta alla beggar off in questione, e precisamente si trova a :005B3ECE.

 

Riporto di seguito il codice della parte nella quale questo salto avviene:

 

 

* Jump at Address:
|:005B3E6E(C)
|
:005B3E8E mov edi, dword ptr [ebp-5C]
:005B3E91 mov ecx, FFFFFFFF
:005B3E96 sub eax, eax
:005B3E98 repnz
:005B3E99 scasb
:005B3E9A not ecx
:005B3E9C sub edi, ecx
:005B3E9E mov eax, ecx
:005B3EA0 shr ecx, 02
:005B3EA3 mov esi, edi
:005B3EA5 lea edi, dword ptr [ebp+FFFFFDE4]
:005B3EAB repz
:005B3EAC movsd
:005B3EAD mov ecx, eax
:005B3EAF and ecx, 00000003
:005B3EB2 repz
:005B3EB3 movsb
:005B3EB4 lea ecx, dword ptr [ebp-28]
:005B3EB7 lea eax, dword ptr [ebp+FFFFFDE4]
:005B3EBD push ecx
:005B3EBE push 00000000
:005B3EC0 push eax
:005B3EC1 call 00411000
:005B3EC6 add esp, 0000000C
:005B3EC9 mov dword ptr [ebp-10], eax
:005B3ECC test eax, eax
:005B3ECE je 005B400F
:005B3ED4 lea eax, dword ptr [ebp-5C]
:005B3ED7 lea ecx, dword ptr [ebp-20]
:005B3EDA push eax


Osserviamo un po' la situazio: come abbiamo visto, il salto alla messagebox si attiva al 5� tentativo di registrazione fallito. Ecco allora che al codice sopra spetta il compito di controllare QUANTE volte � stato premuto il tasto "OK". Affinch� per� questa procedura sia eseguita, deve esserci prima qualcosa che decide se il serial � o non � scazzato. Cosa potrebbe essere? Guardando sopra sembrerebbe abbastanza semplice: si tratta della CALL a :005B3EC1. Entrandoci, essa si presenter� cos�:

 

* Referenced by a CALL at Addresses:
|:00411617 , :0051C39F , :005B3E17 , :005B3EC1
|
:00411000 sub esp, 0000000C <-- C=12
:00411003 lea eax, dword ptr [esp+04]
:00411007 push esi
:00411008 xor esi, esi
:0041100A push eax
:0041100B lea ecx, dword ptr [esp+08]
:0041100F mov dword ptr [esp+0C], esi
:00411013 mov dword ptr [esp+08], esi
:00411017 push ecx
:00411018 mov dword ptr [esp+14], esi
:0041101C call 004115D0
:00411021 lea ecx, dword ptr [esp+14]
:00411025 mov edx, dword ptr [esp+0C]
:00411029 mov eax, dword ptr [esp+10]
:0041102D add esp, 00000008
:00411030 push ecx
:00411031 push edx
:00411032 mov ecx, dword ptr [esp+20]
:00411036 push eax
:00411037 mov edx, dword ptr [esp+20]
:0041103B push ecx
:0041103C push edx
:0041103D call 00411080 <-- CALL del checking
:00411042 add esp, 00000014
:00411045 test eax, eax <-- TESTA IL SERIAL: CORRISPONDE? SI?
:00411047 je 0041106F <-- SALTA!!
:00411049 mov eax, dword ptr [esp+1C]
:0041104D cmp dword ptr [esp+0C], esi
:00411051 jne 0041105F
:00411053 mov dword ptr [eax], esi

 

Ecco dove fa riferimento la CALL precedente. Notiamo che c'� un'altra CALL a 0041103D implicata probabilmente in una manipolazione del serial. Subito dopo questa c'� un test di eax e subito dopo un je, il quale sicuramente � qualcosa che influisce nel checking del valore da noi inserito... hum..., io proverei a cambiarlo in qualcos'altro... segnamoci l'OFFSET: 10447. Avviamo HIEW, apriamo il file Dreamweaver.exe, solito F4/Decode, F5, Scriviamo l'OFFSET, F3 per cambiare il byte da 74 (je) a 75 (jne). Salviamo con F9, usciamo con F10, avviamo di nuovo il Dreamweaver e... il prog. parte regolarmente!! Meravigliaaa!!!!!! E' registrato!!!!! Nun ce credooo!! Bravi raga, se ci siete riusciti complimenti, altrimenti jmp Essay ;))

 

Il je a 00411047 dunque era proprio il jump decisivo che decretava la registrazione o la beggar-off. Cambiandolo in jnz, di conseguenza, il programma lo controller�, si registrer� e si avvier� normalmente. Perfetto, cracking riuscito... tutorial finito!!!

 

Ultima nota: se aprite il regedit e andate in HKEY_LOCAL_MACHINE\Software\Macromedia\Dreamweaver\2\Registration (dove cio� il serial viene salvato e letto ogni volta che viene avviato il programma), vedrete alcune voci. Se cambiate il valore di "Serial Number", nella schermata iniziale del programma in basso a sinistra apparir� ci� che voi avete inserito, quindi se volete cambiate il valore come + vi garba, tanto il prog. � crackato!!

 

Happy cracking a tutti!!

 

                                                                                                     Ritz

Vabb�, ora meglio staccare, e velocemente anche, che de 'sto tute ne ho due maroni cos� (visto che ormai � anche tempo di castagne ;)) (* nota: da noi castagne si dice anche "maroni" *), quindi procediamo coi saluti. Saluto Quequero, che con la mail nella ml mi ha convinto a crackare il prog. in questione che avevo ormai abbandonato ;)), BlackDruiD, [aLT255], cod, WhiteFly, xOA, la ml dell'UIC (intendo i partecipanti ;) ), TiN_Man, acidone, Guybrush, i vari ring0 che varie volte incontro su IRC secondo un criterio totalmente random (a parte WhiteFly che c'� quasi sempre quando ci sono io), BoBo, Nobody88. Greets also to Dephra 'n RafCrash, due amici. Infine, un fuckkkkk ai vari lame del pianeta e ai prof. stronzi (presenti sempre in abundantia: ao quelli non mancano mai ehh??). Riciauzzzz a tutti by Ritz.

Vorrei ricordare che il software va comprato e non rubato, dovete registrare legalmente 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