Hack questo sito!

[ Advertise With HackThisSite.org :: Hide These Ads ] [Pubblicità HackThisSite.org:: Nascondi questi annunci]

"The United States is like the guy at the party who gives cocaine to everybody and still nobody likes him." "Gli Stati Uniti sono come il ragazzo al partito che dà cocaina a tutti e ancora nessuno lo ama". - Jim Samuels - Jim Samuels

HTS costs up to $300 a month to operate. HTS costi fino a $ 300 al mese per funzionare. We need your help! Abbiamo bisogno del vostro aiuto!

Donors also receive special recognition on our donors page. Anche i donatori ricevono un riconoscimento speciale sui nostri donatori pagina.

FR DE ES IT PT FR DE ES IT PT

Link to us! Link al nostro sito!

phoenix free shells fenice libera gusci
hackergames.net hackergames.net
PullThePlug PullThePlug

Basic Reverse Engineering with White Scorpion Reverse Engineering di base bianca con Scorpion
Published by: white_scorpion , on 2008-02-09 02:45:05 Pubblicato da: white_scorpion, su 2008-02-09 02:45:05
Basic Reverse Engineering with White Scorpion Reverse Engineering di base bianca con Scorpion For this "tutorial" we will use a real program called PDF2Word. Per questo "tutorial" useremo un vero e proprio programma chiamato PDF2Word. I stumbled upon this program when trying to convert a pdf document to a word document (duh..). I incappato su questo programma quando si cerca di convertire un documento PDF ad un documento di Word (duh..). The funny thing on this program is that it costs $39.95 and that it is released under the GPL. La cosa divertente di questo programma è che costa $ 39.95 e che è rilasciato sotto la licenza GPL. Let's start shall we? Iniziamo così? 1: Obtain a copy of the program, We will use version 1.6 in this tutorial (You'll need 1: Ottenere una copia del programma, useremo la versione 1.6 di questo tutorial (Avrai bisogno Google to get this version). Google per ottenere questa versione). 2: Obtain a copy of ollydbg at http://www.ollydbg.de 2: Ottenere una copia di ollydbg a http://www.ollydbg.de Start PDF2Word and you will see a screen with title "Please register .." Inizio PDF2Word e vedrete una schermata con il titolo "Si prega di registro .." Type in an email address and a bogus registration key and hit OK. Digitare un indirizzo e-mail e una falsa chiave di registrazione e premere OK. Write down the error message you get since we will need it later on: Scrivere il messaggio di errore viene visualizzato quando abbiamo servirà più avanti: "Series number error, please check it and try again." "Numero di serie errore, vi preghiamo di verificare e provare di nuovo." Now close pdf2word and start Ollydbg. Ora chiudere pdf2word e iniziare Ollydbg. From within ollydbg go to file, open and browse to Da ollydbg andare a file, aprire e sfogliare per C:Program FilesPDF2Word v1.6 and select pdf2rtf.exe . C: Programmi FilesPDF2Word v1.6 e selezionare pdf2rtf.exe. Once the program is loaded right-click somewhere in the code table and select Search for Una volta che il programma è caricato cliccate con il tasto destro in qualche parte del codice tavolo e selezionare Cerca per Then select All referenced text strings". Quindi selezionare Tutte le stringhe di testo di riferimento ". A new window will open with all text strings in the program. Si aprirà una nuova finestra con tutte le stringhe di testo nel programma. Scroll up and right-click once more. Scorrere verso l'alto e cliccate con il tasto destro una volta di più. Now select [i]Search for text and put in the errorstring you had earlier in the program: A questo punto, selezionare [i] Ricerca di testo e mettere in ErrorString avete avuto in precedenza in programma: "Series number error, please check it and try again." . "Numero di serie errore, vi preghiamo di verificare e provare di nuovo.". deselect "Case Sensitive" and press OK. deselezionare "Case Sensitive" e premere OK. You will see the following line highlighted: Vedrete la seguente riga evidenziata: CODE : CODICE: `00429F6F \| PUSH pdf2rtf.00468270 \| ASCII "Series number error, please check it and try again."` `00429F6F \| PRESS pdf2rtf.00468270 \| ASCII "numero di serie errore, vi preghiamo di verificare e provare di nuovo."` Now press <F2> to put a breakpoint on it. Ora premere <F2> a mettere un punto di interruzione su di esso. Directly above you will find some other strings Direttamente al di sopra troverete alcune altre stringhe which might be of interest as well so put a breakpoint on them to. che potrebbero essere di interesse e mettere così un punto di interruzione su di loro per. These are: Questi sono i seguenti: "Thank you registered" and "Thank you registered VeryPDF PDF2Word v1.6." "Grazie registrati" e "Grazie registrato VeryPDF PDF2Word v1.6". Now double click on one of the lines and press <F9> to start the program. Ora fare doppio clic su una delle linee e premere <F9> per avviare il programma. The registration window will come up again, so now put in an email address, a dummy registration-key La finestra di registrazione verrà di nuovo, così ora messo in un indirizzo di posta elettronica, un manichino-chiave di registrazione and press OK. e premere OK. Go back to Olly and you will see the following line highlighted: Torna alla Olly e vedrete la riga riportata di seguito evidenziato: CODE : CODICE: `00429F6F .` `00429F6F.` `68 70824600 PUSH pdf2rtf.00468270 ; \|Text = "Series number error, please check it and try again."` `68 70824600 PUSH pdf2rtf.00468270; \| Text = "numero di serie errore, vi preghiamo di verificare e provare di nuovo."` This is our error message again and the program has stopped right before displaying it. Questo è il nostro messaggio di errore e di nuovo il programma si è fermato a destra prima di visualizzarlo. You can see this error message is part of a [color=red]MessageBoxA[/color] call, this is the Potete vedere questo messaggio di errore è parte di un [color = red] MessageBoxA [/ color] chiamata, questa è la API responsible for displaying the Message. API responsabile per la visualizzazione del messaggio. If you look a couple of lines earlier you will Se cercate un paio di linee in precedenza si see another MessageBoxA call where instead of our errormessage now the vedere un altro invito MessageBoxA dove invece del nostro errormessage ora message "Thank you registered VeryPDF PDF2Word v1.6." is located. messaggio "Grazie registrato VeryPDF PDF2Word v1.6." si trova. This means that if we have the correct serial it will display the registered message, and if Ciò significa che se abbiamo la corretta seriale che viene visualizzato il messaggio registrato, e se we don't we will get the error. noi non potremo ottenere l'errore. The program will need to decide if your serial is correct before it can display any of these Il programma dovrà decidere se il tuo seriale è corretto prima di poter visualizzare uno qualsiasi di questi messages. messaggi. The code to do so is usually located close to the messages so scroll up a bit until Il codice per farlo è di solito si trova vicino ai messaggi scorrere verso l'alto in modo un po 'fino a quando you see a piece of code containing a JNE,JE,JNZ or JZ. si vede un pezzo di codice contenente un JNE, JE, JNZ o JZ. These are jumps that occur when a specific Si tratta di salti che si verificano quando uno specifico event is met. caso è soddisfatta. Usually the event is tested in the code directly in front of it. Di solito l'evento è sottoposto a test in codice direttamente di fronte. In this case you should end up at the following lines: In questo caso si dovrebbe fino a fine le seguenti righe: CODE : CODICE: `00429F2E .` `00429F2E.` `85C0 TEST EAX,EAX` `85C0 TEST EAX, EAX` `00429F30 .` `00429F30.` `74 39 JE SHORT pdf2rtf.00429F6B` `74 39 JE BREVE pdf2rtf.00429F6B` As you can see EAX is tested against itself which in this case will jump to 00429F6B if Come si può vedere EAX viene testato contro se stesso che in questo caso salta al 00429F6B se EAX has the value 0. EAX ha il valore 0. if we trace the jump we will see that it will jump over the registered message and end up se si traccia il salto vedremo che salta il messaggio registrato e alla fine right before the error message. a destra prima del messaggio di errore. This means that if EAX = 0 we will get the error message and Ciò significa che se EAX = 0 ci sarà il messaggio di errore e our serial is wrong. la nostra serie è sbagliato. At this point we could remove the JE SHORT pdf2rtf.00429F6B code and fill it with A questo punto si può rimuovere il JE BREVE pdf2rtf.00429F6B e compilare il codice con NOP so we will always get the correct message since the jump is never made, but that won't help Pon così tutto per ottenere il corretto messaggio in quanto il salto non è mai fatta, ma che non aiutano here cause if you restart the program it will still ask you to register. qui causare se si riavvia il programma sarà ancora chiederle di registro. So we need to continue our search. Quindi abbiamo bisogno di continuare la nostra ricerca. We need to figure out where EAX is getting it's value from. Abbiamo bisogno di capire dove si sta EAX è di valore. 2 lines above TEST EAX,EAX we see 2 righe sopra TEST EAX, EAX vediamo CODE : CODICE: `00429F26 .` `00429F26.` `E8 F5F7FFFF CALL pdf2rtf.00429720` `E8 F5F7FFFF chiamata pdf2rtf.00429720` This is a call to a function somewhere else in the program and you can bet your life it is this Questa è una chiamata a una funzione da qualche altra parte nel programma e potete scommettere la vostra vita è questa function that sets the EAX value. funzione che imposta il valore di EAX. And so we need to figure out what this function does. E così abbiamo bisogno di capire che cosa fa questa funzione. To do this we will put another breakpoint Per fare questo è necessario mettere un altro di interruzione at CALL pdf2rtf.00429720 by highlighting the line and press <F2>. INVITO a pdf2rtf.00429720 evidenziando la riga e premere <F2>. Now we want to restart the program to make it break on the function call. Ora vogliamo riavviare il programma per renderlo pausa sulla chiamata di funzione. This is done by Questo è fatto da pressing <CTRL>+<F2>. premendo <Ctrl> + <F2>. Select YES to the question asked (press left arrow and hit enter) and the program is restarted. Selezionare YES per la domanda posta (premere freccia sinistra e premere Invio) e il programma viene riavviato. Now press <F9> again to let the program run. Ora <F9> premere di nuovo per far funzionare il programma. You will see the registration box pop-up again, so put in an email address and a bogus serial and press OK. Vedrete la registrazione casella di pop-up di nuovo, in modo messo in un indirizzo e-mail e una serie fasullo e premere OK. As you can see the program will break on the CALL pdf2rtf.00429720 line. Come si può vedere il programma in pausa INVITO pdf2rtf.00429720 linea. Now press <F7> to step into the call. Ora premere <F7> a passo nella chiamata. The first 4 lines are not of interest to us so we will start analyzing the code from 00429725 . Le prime 4 linee non sono di interesse per noi in modo potremo iniziare analizzando il codice 00429725. The code we have there is Il codice che abbiamo ci è CODE : CODICE: `00429725 \|.` `00429725 \|.` `8B7424 3C MOV ESI,DWORD PTR SS:[ESP+3C]` `8B7424 3C MOV ESI, DWORD PTR SS: [ESP 3 C]` `00429729 \|.` `00429729 \|.` `57 PUSH EDI` `57 PUSH EDI` `0042972A \|.` `0042972A \|.` `8A06 MOV AL,BYTE PTR DS:[ESI]` `8A06 MOV AL, BYTE PTR DS: [ESI]` `0042972C \|.` `0042972C \|.` `8A4E 01 MOV CL,BYTE PTR DS:[ESI+1]` `8A4E 01 MOV CL, BYTE PTR DS: [ESI 1]` `0042972F \|.` `0042972F \|.` `8A56 0E MOV DL,BYTE PTR DS:[ESI+E]` `8A56 0E MOV DL, BYTE PTR DS: [ESI + E]` `00429732 \|.` `00429732 \|.` `884424 18 MOV BYTE PTR SS:[ESP+18],AL` `884.424 18 MOV BYTE PTR SS: [ESP 18], AL` `00429736 \|.` `00429736 \|.` `32C0 XOR AL,AL` `32C0 XOR AL, AL` `00429738 \|.` `00429738 \|.` `884C24 30 MOV BYTE PTR SS:[ESP+30],CL` `884C24 30 MOV BYTE PTR SS: [ESP 30], CL` `0042973C \|.` `0042973C \|.` `8A4E 0F MOV CL,BYTE PTR DS:[ESI+F]` `8A4E 0F MOV CL, BYTE PTR DS: [ESI + F]` `0042973F \|.` `0042973F \|.` `884424 19 MOV BYTE PTR SS:[ESP+19],AL` `884.424 19 MOV BYTE PTR SS: [ESP 19], AL` `00429743 \|.` `00429743 \|.` `884424 31 MOV BYTE PTR SS:[ESP+31],AL` `884.424 31 MOV BYTE PTR SS: [ESP 31], AL` `00429747 \|.` `00429747 \|.` `884424 25 MOV BYTE PTR SS:[ESP+25],AL` `884.424 25 MOV BYTE PTR SS: [ESP 25], AL` `0042974B \|.` `0042974B \|.` `884424 0D MOV BYTE PTR SS:[ESP+D],AL` `884424 0D MOV BYTE PTR SS: [ESP + D], AL` `0042974F \|.` `0042974F \|.` `8A46 02 MOV AL,BYTE PTR DS:[ESI+2]` `8A46 02 MOV AL, BYTE PTR DS: [ESI 2]` `00429752 \|.` `00429752 \|.` `3C 24 CMP AL,24` `3C 24 CMP AL, 24` `00429754 \|.` `00429754 \|.` `885424 24 MOV BYTE PTR SS:[ESP+24],DL` `885.424 24 MOV BYTE PTR SS: [ESP 24], DL` `00429758 \|.` `00429758 \|.` `884C24 0C MOV BYTE PTR SS:[ESP+C],CL` `884C24 0C MOV BYTE PTR SS: [ESP + C], CL` `0042975C \|.` `0042975C \|.` `75 52 JNZ SHORT pdf2rtf.004297B0` `75 52 JNZ BREVE pdf2rtf.004297B0` I've copied the entire block until the first check of the serial above to safe space, so refer Ho copiato l'intero blocco fino a quando il primo controllo dei seriale di sopra di spazio sicuro, si riferiscono in modo to above code in this explanation. sopra il codice a questa spiegazione. [quote] 1st line --> move our entered serial to ESI 1a linea -> spostare i nostri iscritti seriale a ESI 2nd line --> not important 2a linea -> non ha importanza 3rd line --> move the first byte (character) of our serial into AL 3a linea -> spostare il primo byte (carattere) della nostra serie in AL 4th line --> move the second byte (first+1) of our serial into CL 4a linea -> spostare il secondo byte (prima 1) della nostra serie in CL 5th line --> move the 13th byte (first+E) of our serial into DL 5a linea -> spostare il 13 byte (primo + E) della nostra serie in DL 6th line --> move content of AL (first character of our serial) into [ESP+18] 6a linea -> spostare il contenuto di AL (primo carattere del nostro seriale) in [ESP 18] 7th line --> clear the contents of AL 7a linea -> cancellare il contenuto di AL 8th line --> move the content of CL (second character) into [ESP+30] 8a linea -> spostare il contenuto del CL (secondo carattere) in [ESP 30] 9th line --> move the 14th byte (first+F) of our serial into CL 9a linea -> spostare il 14o byte (primo + F) della nostra serie in CL 10th,11th,12th,13th line --> clear the contents of [ESP+19],[ESP+31],[ESP+25] & [ESP+D] since AL still is empty. 10, 11, 12, 13 linea -> cancellare il contenuto di [ESP 19], [ESP 31], [ESP 25] e [ESP + D] AL poiché è ancora vuoto. 14th line --> move the third byte (first+2) of our serial into AL 14a linea -> spostare il terzo byte (prima 2) della nostra serie in AL 15th line --> compare content of AL with 0x24 (hex for the $ sign) 15a linea -> confronta il contenuto di AL con 0x24 (esadecimale per il segno $) 16th line --> move the 13th byte of our serial into [ESP+24] 16a linea -> spostare il 13 byte della nostra serie in [ESP 24] 17th line --> move the 14th byte of our serial into [ESP+C] 17a linea -> spostare il 14o byte del nostro seriale in [ESP + C] 18th line --> Jump to 004297B0 if AL is not equal to 24 ($ sign). 18a linea -> Vai a 004297B0 AL se non è uguale a 24 ($ segno). [/quote] [/ quote] If you trace the jump in the 18th line you will see that it jumps to the following code: Se si traccia il salto in linea 18a vedrete che salta al seguente codice: CODE : CODICE: `004297B0 \|> 5F POP EDI` `004297B0 \|> 5F POP EDI` `004297B1 \|.` `004297B1 \|.` `5E POP ESI` `5E POP ESI` `004297B2 \|.` `004297B2 \|.` `33C0 XOR EAX,EAX` `33C0 XOR EAX, EAX` `004297B4 \|.` `004297B4 \|.` `5D POP EBP` `5D POP EBP` `004297B5 \|.` `004297B5 \|.` `83C4 30 ADD ESP,30` `83C4 ADD ESP 30, 30` `004297B8 .` `004297B8.` `C3 RETN` `C3 RETN` Which means so much as restore values, set EAX to 0 and return from where we were called. Il che significa tanto come ripristinare i valori, impostare a 0 EAX e ritornare da dove siamo stati chiamati. If we let this happen then EAX will be 0 which will give us the error message. Se lasciamo che questo accada poi EAX sarà 0, che ci darà il messaggio di errore. So what do we know now from this code? Che cosa sappiamo ora da questo codice? - AL should be equal to 0x24 or we will get the error message - AL dovrebbe essere pari a 0x24 o si riceve il messaggio di errore - the program moves the third character of our serial into AL before comparing it to 0x24 - Il programma si muove il terzo carattere della nostra serie in prima AL confronto a 0x24 - the program moves the 14th byte of our serial into CL - Il programma si sposta il 14 byte della nostra serie in CL from above we can conclude that the third character of our serial should be a $ sign and da sopra si può concludere che il terzo carattere della nostra serie dovrebbe essere un segno e $ that our serial should be at least 14 characters long since the 14th character is moved. che il nostro seriale deve essere di almeno 14 caratteri lungo poiché la 14a carattere viene spostato. So our serial will be something like: ..$........... Quindi la nostra serie sarà qualcosa di simile: ..$........... It's time for the next piece of code: E 'tempo per il prossimo pezzo di codice: CODE : CODICE: `0042975E \|.` `0042975E \|.` `8B3D 4C964400 MOV EDI,DWORD PTR DS:[<&MSVCRT.atoi>] ; msvcrt.atoi` `8B3D 4C964400 MOV EDI, DWORD PTR DS: [<& MSVCRT.atoi>]; msvcrt.atoi` `00429764 \|.` `00429764 \|.` `8D5424 0C LEA EDX,DWORD PTR SS:[ESP+C]` `8D5424 0C LEA EDX, DWORD PTR SS: [ESP + C]` `00429768 \|.` `00429768 \|.` `52 PUSH EDX ; /s` `52 PUSH EDX; / s` `00429769 \|.` `00429769 \|.` `FFD7 CALL EDI ; atoi` `FFD7 CALL EDI; atoi` `0042976B \|.` `0042976B \|.` `8BE8 MOV EBP,EAX` `8BE8 MOV EBP, EAX` `0042976D \|.` `0042976D \|.` `8D4424 1C LEA EAX,DWORD PTR SS:[ESP+1C]` `8D4424 1C LEA EAX, DWORD PTR SS: [1 ESP C]` `00429771 \|.` `00429771 \|.` `50 PUSH EAX` `50 PUSH EAX` `00429772 \|.` `00429772 \|.` `FFD7 CALL EDI` `FFD7 chiamata EDI` `00429774 \|.` `00429774 \|.` `03E8 ADD EBP,EAX` `03E8 ADD EBP, EAX` `00429776 \|.` `00429776 \|.` `83C4 08 ADD ESP,8` `83C4 08 ADD ESP, 8` `00429779 \|.` `00429779 \|.` `83FD 0A CMP EBP,0A` `83FD 0A CMP EBP, 0A` `0042977C \|.` `0042977C \|.` `75 32 JNZ SHORT pdf2rtf.004297B0` `75 32 JNZ BREVE pdf2rtf.004297B0` Let's analyze it: Let's analizzare è del seguente tenore: [quote] 1st line --> move the address of the function MSVCRT.atoi to EDI 1a linea -> spostare l'indirizzo della funzione di MSVCRT.atoi EDI atoi is a function which converts ASCII characters to integers (numbers). atoi è una funzione che converte i caratteri ASCII a numeri interi (numeri). 2nd line --> put the 16th byte of our serial into EDI 2a linea -> messo la 16a byte della nostra serie in EDI 3rd line --> push our byte to the stack as an argument to atoi 3a linea -> spingere il nostro byte per lo stack come un argomento per atoi 4th line --> call atoi. 4a linea -> chiamata atoi. the result will be in EAX il risultato sarà in EAX 5th line --> move content of EAX into EBP 5a linea -> spostare il contenuto di EAX in EBP 6th line --> move the first byte of our serial into EAX 6a linea -> spostare il primo byte del nostro seriale in EAX 7th line --> push our byte to the stack as an argument to atoi 7a linea -> spingere il nostro byte per lo stack come un argomento per atoi 8th line --> call atoi. 8a linea -> chiamata atoi. the result will be in EAX il risultato sarà in EAX 9th line --> add EAX to EBP and store the result in EBP 9a linea -> per aggiungere EAX EBP e memorizzare il risultato in EBP 10th line --> not important to us 10a linea -> non importante per noi 11th line --> compare EBX with the value 0x0A (10) Linea 11 -> EBX confrontare con il valore 0x0A (10) 12th line --> if EBX is not 0x0A then jump to 004297B0 (put 0 into EAX and return). Linea 12 -> EBX se non è 0x0A poi passare alla 004297B0 (0 mettere in EAX e ritorno). [/quote] [/ quote] NOTE: You probably wonder how i figured out which byte is used to put into atoi, well here NOTA: è probabilmente chiedo come i figurato di byte che viene utilizzato per mettere in atoi, anche qui it is: I've put in serials multiple times with different digits as values and compared them to che è: ho messo in serie più volte con diverse cifre di valori e di rispetto the output of atoi in EAX. l'output di atoi in EAX. This resulted in the corresponding bytes. Ciò ha portato nel corrispondente byte. What do we know from this code? Che cosa sappiamo di questo codice? - our 16th byte is put into EDI, this means that our serial must be at least 16 characters long - Il nostro 16a byte è messo in EDI, questo significa che il nostro seriale deve essere di almeno 16 caratteri lungo - the 16th byte is put into atoi, which means it much have a value between 0-9 - 16 byte è messo in atoi, il che significa che molto hanno un valore compreso tra 0-9 - the 1st byte is put into atoi as well, which also means it must have a value between 0-9 - Il 1 ° byte è messo in atoi come bene, che significa anche che deve avere un valore compreso tra 0-9 - the value of our first byte is added to the value of our 16th byte and together they must be - Il valore del nostro primo byte è aggiunto il valore del nostro 16a byte e insieme devono essere equal to 0xA (10). pari a 0xA (10). So now we have the following serial: 1.$............9 Così ora abbiamo la seguente serie: 1 .$............ 9 as you can imagine the values of our 1st and 16th byte can be anything as long as they both come potete immaginare i valori della nostra 1a e 16 byte possono essere qualsiasi cosa, purché sia are digits and when added to each other are equal to 10 decimal. sono cifre e quando aggiunta ad ogni altro sono pari a 10 decimale. Time for the next piece of code: Tempo per il prossimo pezzo di codice: CODE : CODICE: `0042977E \|.` `0042977E \|.` `8D4C24 24 LEA ECX,DWORD PTR SS:[ESP+24]` `8D4C24 24 LEA ecx, DWORD PTR SS: [ESP 24]` `00429782 \|.` `00429782 \|.` `51 PUSH ECX` `51 PUSH ecx` `00429783 \|.` `00429783 \|.` `FFD7 CALL EDI` `FFD7 chiamata EDI` `00429785 \|.` `00429785 \|.` `8D5424 34 LEA EDX,DWORD PTR SS:[ESP+34]` `8D5424 34 LEA EDX, DWORD PTR SS: [ESP 34]` `00429789 \|.` `00429789 \|.` `8BE8 MOV EBP,EAX` `8BE8 MOV EBP, EAX` `0042978B \|.` `0042978B \|.` `52 PUSH EDX` `52 PUSH EDX` `0042978C \|.` `0042978C \|.` `FFD7 CALL EDI` `FFD7 chiamata EDI` `0042978E \|.` `0042978E \|.` `03E8 ADD EBP,EAX` `03E8 ADD EBP, EAX` `00429790 \|.` `00429790 \|.` `83C4 08 ADD ESP,8` `83C4 08 ADD ESP, 8` `00429793 \|.` `00429793 \|.` `83FD 0A CMP EBP,0A` `83FD 0A CMP EBP, 0A` `00429796 \|.` `00429796 \|.` `75 18 JNZ SHORT pdf2rtf.004297B0` `75 18 JNZ BREVE pdf2rtf.004297B0` Let's analyze it: Let's analizzare è del seguente tenore: [quote] 1st line --> our 15th byte is put into ECX 1a linea -> la nostra 15a byte è messo in ecx 2nd line --> push our byte to the stack as an argument to atoi 2a linea -> spingere il nostro byte per lo stack come un argomento per atoi 3rd line --> call atoi. 3a linea -> chiamata atoi. the result will be in EAX il risultato sarà in EAX 4th line --> our 2nd byte is put into EDX 4a linea -> Il nostro 2 ° byte è messo in EDX 5th line --> move the result of atoi into EBP 5a linea -> spostare il risultato di atoi in EBP 6th line --> push our 2nd byte to the stack as an argument to atoi 6a linea -> spingere il nostro 2 ° byte per lo stack come un argomento per atoi 7th line --> call atoi. 7a linea -> chiamata atoi. the result will be in EAX il risultato sarà in EAX 8th line --> add the result of our 15th and 2nd byte together and store in EBP 8a linea -> aggiungere il risultato del nostro 15 ° e il 2 ° byte insieme e conservare in EBP 9th line --> not important to us. 9a linea -> non importante per noi. 10th line --> check if our 15th byte + our 2nd byte added together is equal to 0x0A (10). 10a linea -> verificare se il nostro 15a byte + il nostro 2 ° byte aggiunto insieme è pari a 0x0A (10). 11th line --> if not, then another jump to 004297B0 Linea 11 -> se non, poi un altro salto di 004297B0 [/quote] [/ quote] As you can see this code is very similar to the codeblock before, so i won't explain it any Come si può vedere questo codice è molto simile al codeblock prima, così non mi spiegare che qualsiasi further. più avanti. Now we have the following serial: 12$...........89 Ora abbiamo le seguenti serie: 12 $........... 89 We still need to analyze some code, but we're getting somewhere ;-) Abbiamo ancora bisogno di analizzare un po 'di codice, ma siamo ottenere qualche ;-) Lets take a look at the final piece of code from this call: Diamo un'occhiata alla finale pezzo di codice da questa chiamata: CODE : CODICE: `00429798 \|.` `00429798 \|.` `807E 03 24 CMP BYTE PTR DS:[ESI+3],24` `807E 03 24 CMP BYTE PTR DS: [ESI 3], 24` `0042979C \|.` `0042979C \|.` `75 12 JNZ SHORT pdf2rtf.004297B0` `75 12 JNZ BREVE pdf2rtf.004297B0` `0042979E \|.` `0042979E \|.` `8A4E 05 MOV CL,BYTE PTR DS:[ESI+5]` `8A4E 05 MOV CL, BYTE PTR DS: [ESI 5]` `004297A1 \|.` `004297A1 \|.` `33C0 XOR EAX,EAX` `33C0 XOR EAX, EAX` `004297A3 \|.` `004297A3 \|.` `80F9 23 CMP CL,23` `80F9 23 CMP CL, 23` `004297A6 \|.` `004297A6 \|.` `5F POP EDI` `5F POP EDI` `004297A7 \|.` `004297A7 \|.` `5E POP ESI` `5E POP ESI` `004297A8 \|.` `004297A8 \|.` `5D POP EBP` `5D POP EBP` `004297A9 \|.` `004297A9 \|.` `0F94C0 SETE AL` `0F94C0 SETE AL` `004297AC \|.` `004297AC \|.` `83C4 30 ADD ESP,30` `83C4 ADD ESP 30, 30` `004297AF \|.` `004297AF \|.` `C3 RETN` `C3 RETN` Analysis: Analisi: [quote] 1st line --> since ESI still contains our serial, the 4th byte is now checked against value 0x24 1a linea -> ESI, poiché contiene ancora la nostra serie, il 4 ° byte è ora controllato contro il valore di 0x24 2nd line --> if not equal, then goto the famous 004297B0 2a linea -> se non uguali, quindi vai alla famosa 004297B0 3rd line --> move our 6th byte to CL 3a linea -> spostare il nostro 6 ° byte al CL 4th line --> check if our 6th byte is equal to 0x23 (# sign) 4a linea -> verificare se il nostro 6 ° byte è pari a 0x23 (# segno) 5th,6th,7th line --> not important 5a, 6 °, 7 ° linea -> non ha importanza 8th line --> sets the byte in AL to 1 if our check above is equal 8a linea -> imposta il byte in AL a 1 se il nostro controllo di cui sopra è pari 9th line --> not important 9a linea -> non ha importanza 10th line --> return to where this call was called from. 10a linea -> tornare al punto in cui il presente invito è stato chiamato da. [/quote] [/ quote] What we see here is that our 4th byte is compared to 0x24 ($ sign remember?) as well and that Quello che vediamo qui è che il nostro 4 ° byte è rispetto a 0x24 ($ segno ricordi?), Come bene e che the 6th byte is compared to 0x23 (the # sign). 6 ° byte è rispetto a 0x23 (il segno #). If that is correct then AL is set to 1 meaning EAX won't be 0 and so causing the program to Se questo è corretto quindi AL è impostato su 1 EAX significato non sarà 0 e provocando così il programma di give the registered message. dare il messaggio registrato. In short: In breve: -check if 3th == $ -controllare se == $ 3 ° -check if 1st + 16th == 10 -controllare se 1a + 16a == 10 -check if 15th + 2nd == 10 -controllare se 15a + 2a == 10 -check if 4th == $ -controllare se 4a == $ -check if 6th == # -controllare se 6a == # All other characters are of no importance to create a valid serial so our result will be: Tutti gli altri caratteri non sono di importanza di creare una valida serie in modo che i nostri risultati saranno i seguenti: 12$$.#........89 12 $$.#........ 89 You can fill in the remaining dots with anything you like and as long as the rules above are È possibile compilare i restanti punti con qualcosa che ti piace e fintanto che le norme di cui sopra sono correct you can change the 1th,2nd,15th and 16th byte as well. corretta è possibile modificare il 1 °, 2 °, 15 e 16 byte come bene. Now close OllyDbg and start PDF2Word. Ora chiudere OllyDbg e iniziare PDF2Word. Enter your email-address and enter one of your newly created serials. Inserisci il tuo indirizzo email e inserire uno dei suoi periodici appena creato. When you press ok you will be thanked for registering. Quando si preme ok ti verrà ringraziato per la registrazione. You're welcome ;-) Sei il benvenuto ;-) The result of your entered information is put in a string and written to Il risultato della vostra entrato informazioni è messo in una stringa e scritti %WINDIR%system32pdf2word.dat % WINDIR% system32pdf2word.dat In case you want another serial just delete the dat file and put in a new one. Nel caso in cui si desidera solo un altro seriale eliminare il file dat e mettere in uno nuovo. Of course this is a very simple protection, but it is a nice example to cover the basics of Naturalmente questa è una protezione molto semplice, ma è un buon esempio per coprire le basi di reverse engineering. reverse engineering.
Cast your vote on this article Cast il vostro voto su questo articolo Note: the order of the votes has been reversed. Nota: l'ordine delle votazioni è stato invertito.

Comments: Commento:
Published: 26 comments. Pubblicato: 26 commenti.

genocidepromoter - 07:07 am Saturday February 09th, 2008 genocidepromoter - 07:07 am Sabato 09e febbraio, 2008

lol 10/10 this pwns! lol 10.10 questo pwns! you should write more :) si dovrebbe scrivere di più:)

Roy20 - 01:26 pm Saturday February 09th, 2008 Roy20 - 01:26 pm Sabato 09e febbraio, 2008

nice!!!love olly :P 10/10 bella! amore olly: P 10/10

tjszl1 - 09:24 am Sunday February 10th, 2008 tjszl1 - 09:24 am Domenica 10 febbraio 2008

Good article!I love you! Buona articolo! Ti amo!

lordofwhee - 12:04 pm Sunday February 10th, 2008 lordofwhee - 12:04 pm Domenica 10 febbraio 2008

Always nice to know this kind of thing. Bello che conoscere questo genere di cose. 10/10 10.10

Luckyperfect - 02:43 pm Sunday February 10th, 2008 Luckyperfect - 02:43 pm Domenica 10 febbraio 2008

Good Stuff, Reverse Engineering will get you out of problems or give you a solution to one a lot of times. Good Stuff, Reverse Engineering ti di problemi o di dare una soluzione a uno un sacco di volte.
A learn a lot on this article although I was unable to do its content do to lack of update, the PDF2words 1.6 is no longer available on the NET, all mirrors and Links will download the 3.0 version and the current version of ollydgb doesnt have the \"Search for\" option required on STEP 2 it appears the hold Right Click menu is different. Una imparare molto su questo articolo, anche se non ho potuto fare il suo contenuto fare per mancanza di aggiornamento, la PDF2words 1.6 non è più disponibile sulla rete, tutti gli specchi e link scarica la versione 3.0 e la versione corrente di ollydgb non dispone la \ "Cerca \" opzione su richiesta FASE 2 sembra stiva Fare clic sul pulsante destro del menu è diverso.
Could you please update the article? Potrebbe invitiamo ad aggiornare l'articolo?
Thank you for knowledge Sir I look forward to learn more from you and your colleagues. La ringrazio per la conoscenza di Sir Non vedo l'ora di saperne di più da voi e ai vostri colleghi.
All the best always... Tutte le migliori semper ...
-Luckyperfect- -Luckyperfect -
\"Scientia est Potentia\" \ "Scientia est Potentia \"

tjszl1 - 07:18 am Tuesday February 12th, 2008 tjszl1 - 07:18 am Martedì 12 febbraio 2008

white_scorpion : white_scorpion:
I\'m very angry.It\'s not a malicious software.You can use anti-virus software to check it. I \ 'm molto angry.It \' s non è un "maligno" software.You possibile utilizzare software anti-virus a controllare.

white_scorpion - 03:42 pm Wednesday February 13th, 2008

Donate Donazioni

Challenges Sfide

Get Informed Get Informed

Get Involved Get Involved

Communicate Comunicare

About HTS A proposito di HTS

Translate Tradurre

Partners Partner