In questo tutorial vi insegnerò come scrivere un decripter generico che nonostante la sua semplicità è un ottima base di partenza per progetti più complessi

How to deprotect CDProtector (in inglese è + figo ;))

Scriviamo un semplice decripter
Written by AciD LeO

L'unwrapper con il sorgente

Se proprio dovete proteggere i vostri cd non usate il CDProtector vedrete che è inutle ;)

Tools usati:

Frogice
SoftIce

CdProtector 3.0

Hiew

La home del programma è http://surf.to/nrgcrew ma il lo ho scaricato da suddendischarge

Il programma serve per proteggersi i propri cd da copia; esso crea un cd con un due tracce dummy e protegge l'eseguibile principale in modo che venga decrittato solo se trova il cd originale o almeno così dichiarano ;).

Crakkare il programma in modo che trovi sempre l'eseguibile originale è una passeggiata scriverne un decripter un pò di meno. Avviamo il programma scegliamo come target  da crittare un file a caso (io ho scelto la calcolatrice di windows dopo essermene fatto una copia), impostiamo la cartella delle tracce fantasmi, il messagiio di errore ed infine il codice di decript.. Clikkiamo su Accept e il gioco e fatto. Ora nella cartella del programma compresso ci troviamo questi file:

_cdp16.dat   _CDP16.DLL  _cdp32.dat _CDP32.DLL  e calc.exe (compresso con neolite).

Avviamo l'eseguibile e non parte un tubo. Innanzitutto avviamo Frogice per evitare noie e cominciamo a capire come funziona il tutto. Allora il file calc.exe altri non è che un eseguibile che controlla il se il cd originale è inserito per poi decrittare il file _cdp32.dat che è il nostro eseguibile originale criptato. Procediamo così: settiamo un bpx su RegisterServiceProcess e avviamo calc.exe, softice popperà in questo punto:

.0044EC16:  call .00044E220  <- call a registerserviceprocess
.0044EC1B:  call .00044E2E8   <- tips antiice
.0044EC20:  push 0004518A8 
.0044EC25:  push 000000100 
.0044EC2A: call .000406430 
.0044EC2F:  push 000000104 
.0044EC34:  lea eax,[ebp][0FFFFFEEC]
.0044EC3A: push eax
.0044EC3B: mov eax,[000450138]
.0044EC40:  mov eax,[eax]
.0044EC42:  push eax
.0044EC43:  call .000406410 
.0044EC48:  lea eax,[ebp][0FFFFFEE8]
....
.0044ECB5:  inc ecx
.0044ECB6:  call .000402A60 
.0044ECBB: je .00044ECC7   <- primo check del cd è consigliabile saltare ;)
.0044ECBD: mov eax,000000001 
.0044ECC2: call .000403940 
.0044ECC7: call .00044E2E8 
Continuando troviamo il secondo check a:
.0044E66B: call .000408084 
.0044E670:  test al,al
.0044E672:  je .00044E6B3   <- secondo check anche qui un bel salto
.0044E674:  lea eax,[ebp][0FFFFFE04]
.0044E67A: call .0004083F4 
e l'ultimo check si trova a:
.0044ECDF mov ecx,[ebp][-000C]
.0044ECE2:  mov edx,[ebp][-0008]
.0044ECE5:  mov eax,[ebp][-0004]
.0044ECE8:  call .00044E3F4 
.0044ECED: test al,al
.0044ECEF:  jne .00044ECFB    <- saltiamo !!!!!
.0044ECF1:  mov eax,000000001

et wala il programma parte adesso ci rimane di capire cosa avviene quando viene decrittato e di scrivere un bel decripter su misura ok. Allo scopo un bel bpx su CreateProcessA cade a puntino ripartite rifixate i jmp e vi troverete nel bel mezzo della funzione di decript qui notate subito che con ReadProcessMemory vengono letti i byte crittati decriptati con la chiave (ricordate quel numeretto che avete inserito inizialmente?) e riscritti con WriteProcessMemory poi con un bel ResumeThread fa partire il programma. Se state attenti notate che la zona del processo che viene letta non è altri che l'area di memoria che va dall'entry dell'eseguibile fino alla fine della sezione dove si trova. La routine di decript è:

.00445A41:  lea eax,[ebp][0FFFFEFD8]     
.00445A47:  lea edx,[ebp][0FFFFF7D8]
.00445A4D: mov cl,[eax]
.00445A4F:  xor cl,[ebp][00008]
.00445A52:  mov [edx],cl
.00445A54:  inc edx
.00445A55:  inc eax
.00445A56:  dec esi
.00445A57:  jne .000445A4D 

eax contiene un puntatore all'area di memoria crittata, edx contiene un puntatore a un'area di memoria dove andrà il file decrittato esi contiene il numero di byte da decrittare. Come potete notare il cuore della funzione di decript e l'xor che si trova al VA 445A4F che altro non fa che applicare un xor a tutti i byte crittati con la chiave che avevamo deciso in precedenza: ma dove si trova la chiave direte voi, appesa alla fine del file dico io e adesso vi spiego come viene calcolata:

.00445746: mov al,[ebp][-0007]
.00445749: add al,[ebp][-0006]
.0044574C add al,[ebp][-0005]
.0044574F: add al,[ebp][-000A]
.00445752: add al,[ebp][-0009]
.00445755: sub al,[ebp][-0008]
.00445758: xor al,[ebp][-000B]

Vedete i  7 byte puntati da ebp + spiazzamento si trovano appesi alla fine del file _cdp32.dat se byte sono  x1 x2 x3 x4 x5 x6 x7 la key viene calcolata così (((x1 + x2 +x3 + x5 + x6 ) - x7) xor x4) e adesso il codice del decripter: (per il codice completo clikkate qui sorgente.asm  è scritto in masm.)

Allora:

        lea eax,[eax+ebx+18h]  <-eax puntatore alla prima sezione
        mov cont,1
nextsection: 
        mov ebx,[eax+0ch]    <- ebx rva della sezione 
        cmp ebx,Entry
        jg continua
        add eax,28h  <- eax prossima sezione
        inc cont
       jmp nextsection 
continua:

Tramite queste righe di codice vediamo qual'è la sezione che stata crittata basandoci sul VA della sezione e sul VA dell'entry quando  quest'ultimo diventa maggiore significa che la sezione che ci interessava era quella precedente.

       mov Tmp,eax
       mov ebx,[eax+0ch]
       mov Rva,ebx
       mov ebx,[eax+14h] 
       mov eax,Rva
       sub eax,ebx   <- ebx pointer to raw data
       xchg eax,ebx
       mov eax,Entry
       sub eax,ebx   <- eax raw pointer all'entry
       mov RawEntry,eax
       mov eax,Tmp
       add eax,28h
       mov eax,[eax+14h] 
       mov ebx,RawEntry
       sub eax,ebx  <- eax n° byte da decrittare 

Qui ci calcoliamo il raw pointer all'entry con questa formuletta VAentry - (Virtualoffeset section - RawOffset section) e il numero di byte da decrittare semplicemente sottraendo al rawpointer della section successiva il rawpointer dell'entry. Successivamente il calcolo della key e il ciclo di decripting:

       mov eax,ImgBase
       add eax,filesize
       xor edx,edx
       sub eax,7         <- vi ricordate la storia dei byte appesi alla fine del file eccoli qui
       mov dl,[eax]
       add dh,dl
       mov dl,[eax+1]
       add dh,dl
       mov dl,[eax+2]
       add dh,dl
       mov dl,[eax+4]
       add dh,dl
       mov dl,[eax+5]
       add dh,dl
       mov dl,[eax+6]
       sub dh,dl 
       mov dl,[eax+3]
       xor dh,dl 
       mov key,dh
       mov eax,RawEntry
       add eax,ImgBase    <- eax zona di memoria da decrittare
       mov ecx,Nbyte       <- ecx n° byte da decrittare
decript:
       mov bl,[eax]
       xor bl,key
       mov [eax],bl
       inc eax
       dec ecx
       jnz decript 

e con questo mi sembra di aver detto tutto. Evitate di chiedermi perchè invece di scrivere un decripter non ho crakkato semplicemente l'eseguibile perchè lo considero solo un esercizio di stile. Un ultima cosa ho notato un comportamento anomalo del programma quando l'entry si trova nell'ultima sezione perchè l'autore va a leggere la section successiva e manda tutto a p...e per evitare il ciò ho inserito nel decripter un semplice controllo che evita di farmi fare la figura dello sprovveduto. NON VEDO L'ORA CHE ESCA CDPROTECTOR 4 hihihhihihi

Saluto prima di tutto Andreageddon (a quando un tuo prossimo tute?) e il grande Yado (ho installato crypter e crackme e faccio una gran fatica a riconoscerli non potevi almeno cambiare il nome) il Que (voglio l'op su #crack-it ;)) poi il mio amico x86 (sto aspettando ancora una tua mail) e Gz3r (dove stai?). Inoltre saluto i miei amici del gruppo di TN1 http://www.kickme.to/tn1  in particolare OldMan (spero che anche tu mi pubblichi questo tutorial), Babes (AciD non sta per acido!!!! non mi stancherò mai di ripeterlo), Tano (prometto che te lo scrivo io un programma per gestire condomini al posto di PIGC) e il grande Ghino (senza di lui TN1 non sarebbe lo stesso).

Qui inserirete con questo carattere il vostro piccolo disclaimer, non è obbligatorio però è meglio per voi se c'è. Dovete scrivere qualcosa di simile a: 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 ;))))