Hack este sitio!

[ Advertise With HackThisSite.org :: Hide These Ads ] [Anúnciate con HackThisSite.org:: Ocultar estos anuncios]

"By annihilating desires, you annihilate the mind." "Al aniquilar a los deseos, que aniquilar a la mente." - Claude-Adrien Helvetius - Claude-Adrien Helvetius

HTS costs up to $300 a month to operate. HTS gastos de hasta $ 300 al mes para funcionar. We need your help! Necesitamos tu ayuda!

Donors also receive special recognition on our donors page. Los donantes también recibirán un reconocimiento especial a nuestros donantes página.

FR DE ES IT PT FR DE ES IT PT

Link to us! Enlace con nosotros!

phoenix free shells Phoenix libre de los depósitos
hackergames.net hackergames.net
PullThePlug PullThePlug

Basic Reverse Engineering with White Scorpion Básicos de ingeniería inversa con el escorpión blanco
Published by: white_scorpion , on 2008-02-09 02:45:05 Publicado por: white_scorpion, sobre 2008-02-09 02:45:05
Basic Reverse Engineering with White Scorpion Básicos de ingeniería inversa con el escorpión blanco For this "tutorial" we will use a real program called PDF2Word. Para este "tutorial" vamos a utilizar un programa llamado real PDF2Word. I stumbled upon this program when trying to convert a pdf document to a word document (duh..). Me tropecé a este programa cuando se trata de convertir un documento pdf a un documento de Word (duh..). The funny thing on this program is that it costs $39.95 and that it is released under the GPL. Lo gracioso de este programa es que cuesta $ 39,95 y que es liberado bajo la GPL. Let's start shall we? Empecemos nosotros? 1: Obtain a copy of the program, We will use version 1.6 in this tutorial (You'll need 1: Obtenga una copia del programa, vamos a utilizar la versión 1.6 en este tutorial (Usted necesitará Google to get this version). Google para obtener esta versión). 2: Obtain a copy of ollydbg at http://www.ollydbg.de 2: Obtener una copia de ollydbg en http://www.ollydbg.de Start PDF2Word and you will see a screen with title "Please register .." PDF2Word de inicio y verás una pantalla con el título "Por favor, registro .." Type in an email address and a bogus registration key and hit OK. Escriba una dirección de correo electrónico y una clave de registro falsos y pulse Aceptar. Write down the error message you get since we will need it later on: Anote el mensaje de error, ya te vamos a necesitar más adelante: "Series number error, please check it and try again." "Número de serie de error, por favor, comprueba y vuelve a intentarlo." Now close pdf2word and start Ollydbg. Ahora estrecho pdf2word y empezar a Ollydbg. From within ollydbg go to file, open and browse to Desde ollydbg ir a archivo, abrir y navegar a C:Program FilesPDF2Word v1.6 and select pdf2rtf.exe . C: Programa de FilesPDF2Word v1.6 y seleccione pdf2rtf.exe. Once the program is loaded right-click somewhere in the code table and select Search for Una vez que el programa está cargado clic con el botón derecho en algún lugar de la tabla de códigos y seleccione Buscar Then select All referenced text strings". A continuación, seleccione Todas las cadenas de texto de referencia ". A new window will open with all text strings in the program. Se abrirá una ventana nueva con todas las cadenas de texto en el programa. Scroll up and right-click once more. Desplácese hacia arriba y haga clic con el botón una vez más. Now select [i]Search for text and put in the errorstring you had earlier in the program: Ahora seleccione [i] Búsqueda de texto y poner errorstring en el que había anteriormente en el programa: "Series number error, please check it and try again." . "Número de serie de error, por favor, comprueba y vuelve a intentarlo.". deselect "Case Sensitive" and press OK. anule la selección de "asunto sensible" y pulse Aceptar. You will see the following line highlighted: Verá la siguiente línea de relieve: CODE : CÓDIGO: `00429F6F \| PUSH pdf2rtf.00468270 \| ASCII "Series number error, please check it and try again."` `00429F6F \| PULS pdf2rtf.00468270 \| ASCII "número de serie de error, por favor, comprueba y vuelve a intentarlo."` Now press <F2> to put a breakpoint on it. Ahora presione <F2> para poner un punto de interrupción en él. Directly above you will find some other strings Directamente encima de usted encontrará algunas otras cadenas which might be of interest as well so put a breakpoint on them to. que puedan ser de interés así como a fin de poner un punto de interrupción en ellas para. These are: Estos son: "Thank you registered" and "Thank you registered VeryPDF PDF2Word v1.6." "Gracias registrado" y "Gracias registrado VeryPDF PDF2Word v1.6". Now double click on one of the lines and press <F9> to start the program. Ahora haga doble clic en una de las líneas y pulse <F9> para iniciar el programa. The registration window will come up again, so now put in an email address, a dummy registration-key La ventana de inscripción hasta vendrán de nuevo, por lo que ahora en poner una dirección de correo electrónico, un maniquí de clave de registro and press OK. y pulse Aceptar. Go back to Olly and you will see the following line highlighted: Volver a Olly y verá la siguiente línea de relieve: CODE : CÓDIGO: `00429F6F .` `00429F6F.` `68 70824600 PUSH pdf2rtf.00468270 ; \|Text = "Series number error, please check it and try again."` `68 70824600 PULS pdf2rtf.00468270; \| Texto = "número de serie de error, por favor, comprueba y vuelve a intentarlo."` This is our error message again and the program has stopped right before displaying it. Este es nuestro mensaje de error y de nuevo el programa se ha detenido justo antes de mostrarlo. You can see this error message is part of a [color=red]MessageBoxA[/color] call, this is the Usted puede ver este mensaje de error es parte de una [color = red] MessageBoxA [/ color] llamada, este es el API responsible for displaying the Message. API responsable de mostrar el mensaje. If you look a couple of lines earlier you will Si usted busca un par de líneas antes que see another MessageBoxA call where instead of our errormessage now the MessageBoxA ver otro lugar donde la palabra de nuestro errorMessage ahora la message "Thank you registered VeryPDF PDF2Word v1.6." is located. mensaje "Gracias registrado VeryPDF PDF2Word v1.6." está situado. This means that if we have the correct serial it will display the registered message, and if Esto significa que si tenemos la serie correcto se mostrará el mensaje registrado, y si we don't we will get the error. nosotros no vamos a obtener el error. The program will need to decide if your serial is correct before it can display any of these El programa tendrá que decidir si su serie es correcta antes de que pueda mostrar cualquiera de estos messages. mensajes. The code to do so is usually located close to the messages so scroll up a bit until El código para hacerlo normalmente se encuentra cerca de los mensajes a fin de desplazarse hacia arriba un poco hasta you see a piece of code containing a JNE,JE,JNZ or JZ. usted ve un pedazo de código que contenga un JNE, JE, JNZ o JZ. These are jumps that occur when a specific Estos son saltos que se producen cuando un determinado event is met. caso se cumple. Usually the event is tested in the code directly in front of it. Por lo general, el evento está a prueba en el código directamente en frente de ella. In this case you should end up at the following lines: En este caso debe terminar en las siguientes líneas: CODE : CÓDIGO: `00429F2E .` `00429F2E.` `85C0 TEST EAX,EAX` `85C0 PRUEBA EAX, EAX` `00429F30 .` `00429F30.` `74 39 JE SHORT pdf2rtf.00429F6B` `74 39 JE CORTO pdf2rtf.00429F6B` As you can see EAX is tested against itself which in this case will jump to 00429F6B if Como se puede ver EAX se prueba contra sí misma que en este caso, saltará a si 00429F6B EAX has the value 0. EAX tiene el valor 0. if we trace the jump we will see that it will jump over the registered message and end up si se traza el salto vamos a ver que va a saltar por encima de la registrada mensaje y terminan right before the error message. justo antes de el mensaje de error. This means that if EAX = 0 we will get the error message and Esto significa que si EAX = 0 vamos a obtener el mensaje de error y our serial is wrong. nuestra serie está mal. At this point we could remove the JE SHORT pdf2rtf.00429F6B code and fill it with En este punto podríamos eliminar la JE CORTO pdf2rtf.00429F6B código y llenar con NOP so we will always get the correct message since the jump is never made, but that won't help NOP por lo que siempre obtener el mensaje correcto desde el salto nunca se hizo, pero que no ayuda here cause if you restart the program it will still ask you to register. aquí causa, si reinicia el programa seguirá siendo pedir que se inscriba. So we need to continue our search. Por lo tanto, tenemos que continuar nuestra búsqueda. We need to figure out where EAX is getting it's value from. Tenemos que averiguar donde está EAX es de valor. 2 lines above TEST EAX,EAX we see 2 líneas por encima PRUEBA EAX, EAX vemos CODE : CÓDIGO: `00429F26 .` `00429F26.` `E8 F5F7FFFF CALL pdf2rtf.00429720` `E8 F5F7FFFF llamada pdf2rtf.00429720` This is a call to a function somewhere else in the program and you can bet your life it is this Esta es una llamada a una función en algún otro lugar en el programa y usted puede apostar su vida es esta function that sets the EAX value. función que establece el valor de EAX. And so we need to figure out what this function does. Y así tenemos que averiguar lo que hace esta función. To do this we will put another breakpoint Para ello vamos a poner otro punto de interrupción at CALL pdf2rtf.00429720 by highlighting the line and press <F2>. CONVOCATORIA en pdf2rtf.00429720 poniendo de relieve la línea y pulse <F2>. Now we want to restart the program to make it break on the function call. Ahora queremos reiniciar el programa para hacerlo romper en la llamada a la función. This is done by Esto se hace por pressing <CTRL>+<F2>. pulsando + <CTRL> <F2>. Select YES to the question asked (press left arrow and hit enter) and the program is restarted. Seleccione SÍ a la pregunta (pulse la flecha izquierda y pulsa enter) y el programa se reinicia. Now press <F9> again to let the program run. Ahora presione <F9> de nuevo para que ejecute el programa. You will see the registration box pop-up again, so put in an email address and a bogus serial and press OK. Verá el cuadro de registro de pop-up de nuevo, a fin de poner en una dirección de correo electrónico y una serie de falsas y pulse Aceptar. As you can see the program will break on the CALL pdf2rtf.00429720 line. Como se puede ver el programa va a romper en la Convocatoria pdf2rtf.00429720 línea. Now press <F7> to step into the call. Ahora presione <F7> a paso en la llamada. The first 4 lines are not of interest to us so we will start analyzing the code from 00429725 . Los primeros 4 líneas no son de interés para nosotros por lo que comenzará a analizar el código de 00429725. The code we have there is El código que hemos existe CODE : CÓDIGO: `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 PULS 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` `884424 18 MOV BYTE DE 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 DE 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` `884424 19 MOV BYTE DE PTR SS: [ESP 19], AL` `00429743 \|.` `00429743 \|.` `884424 31 MOV BYTE PTR SS:[ESP+31],AL` `884424 31 MOV BYTE DE PTR SS: [ESP 31], AL` `00429747 \|.` `00429747 \|.` `884424 25 MOV BYTE PTR SS:[ESP+25],AL` `884424 25 MOV BYTE DE PTR SS: [ESP 25], AL` `0042974B \|.` `0042974B \|.` `884424 0D MOV BYTE PTR SS:[ESP+D],AL` `884424 0D MOV BYTE DE 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` `885424 24 MOV BYTE DE PTR SS: [ESP 24], DL` `00429758 \|.` `00429758 \|.` `884C24 0C MOV BYTE PTR SS:[ESP+C],CL` `884C24 0C MOV BYTE DE PTR SS: [ESP + C], CL` `0042975C \|.` `0042975C \|.` `75 52 JNZ SHORT pdf2rtf.004297B0` `75 52 JNZ CORTO pdf2rtf.004297B0` I've copied the entire block until the first check of the serial above to safe space, so refer He copiado todo el bloque hasta el primer control de la serie anterior a espacio seguro, por lo que se refieren to above code in this explanation. al código anterior en esta explicación. [quote] 1st line --> move our entered serial to ESI 1 ª línea -> Mover entrado en nuestra serie de ESI 2nd line --> not important 2 ª línea -> no es importante 3rd line --> move the first byte (character) of our serial into AL 3 ª línea -> mover el primer byte (carácter) de nuestra serie en AL 4th line --> move the second byte (first+1) of our serial into CL 4 ª línea -> Mover el segundo byte (primera +1) de nuestra serie en CL 5th line --> move the 13th byte (first+E) of our serial into DL 5 ª línea -> mover el byte 13 (primera + E) de nuestra serie en DL 6th line --> move content of AL (first character of our serial) into [ESP+18] 6 ª línea -> mover el contenido de AL (primer carácter de nuestra serie) en [ESP +18] 7th line --> clear the contents of AL 7 ª línea -> borrar el contenido de AL 8th line --> move the content of CL (second character) into [ESP+30] 8 ª línea -> mover el contenido de CL (segundo personaje) en [ESP 30] 9th line --> move the 14th byte (first+F) of our serial into CL 9 ª línea -> Mover la 14 ª byte (primera + F) de nuestra serie en 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 ª línea -> borrar el contenido de [ESP 19], [ESP 31], [ESP 25] y [ESP + D] ya que todavía AL está vacía. 14th line --> move the third byte (first+2) of our serial into AL 14a línea -> Mover el tercer byte (primera +2) de nuestra serie en AL 15th line --> compare content of AL with 0x24 (hex for the $ sign) 15a línea -> comparar el contenido de AL con 0x24 (hexadecimal para el signo $) 16th line --> move the 13th byte of our serial into [ESP+24] 16a línea -> mover el byte 13 de nuestra serie en [ESP 24] 17th line --> move the 14th byte of our serial into [ESP+C] 17a línea -> Mover la 14 ª byte de nuestra serie en [ESP C +] 18th line --> Jump to 004297B0 if AL is not equal to 24 ($ sign). 18a línea -> Ir al 004297B0 si AL no es igual a 24 ($ signo). [/quote] [/ quote] If you trace the jump in the 18th line you will see that it jumps to the following code: Si se traza el salto en la 18 ª línea, verá que salta a la siguiente código: CODE : CÓDIGO: `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 30 Agregar ESP, 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. Lo que significa tanto como restablecer los valores, establecidos EAX a 0 y regreso desde donde fueron llamados. If we let this happen then EAX will be 0 which will give us the error message. Si dejamos que esto ocurra luego EAX será 0 que nos dará el mensaje de error. So what do we know now from this code? ¿Qué sabemos ahora de este código? - AL should be equal to 0x24 or we will get the error message - AL debe ser igual a 0x24 o nos pondremos el mensaje de error - the program moves the third character of our serial into AL before comparing it to 0x24 - El programa se mueve el tercer personaje de nuestra serie en AL antes de comparar a 0x24 - the program moves the 14th byte of our serial into CL - El programa se mueve el 14 byte de nuestra serie en CL from above we can conclude that the third character of our serial should be a $ sign and desde arriba, podemos concluir que el tercer personaje de nuestra serie debe ser un signo $ y that our serial should be at least 14 characters long since the 14th character is moved. que nuestra serie debe ser de al menos 14 caracteres de longitud desde la 14 ª carácter se mueve. So our serial will be something like: ..$........... Por lo tanto, nuestro serial será algo así como: ..$........... It's time for the next piece of code: Es tiempo para la próxima pieza de código: CODE : CÓDIGO: `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 PULS EDX; / s` `00429769 \|.` `00429769 \|.` `FFD7 CALL EDI ; atoi` `CONVOCATORIA FFD7 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 PULS EAX` `00429772 \|.` `00429772 \|.` `FFD7 CALL EDI` `FFD7 llamada EDI` `00429774 \|.` `00429774 \|.` `03E8 ADD EBP,EAX` `03E8 Añadir EBP, EAX` `00429776 \|.` `00429776 \|.` `83C4 08 ADD ESP,8` `Añadir 83C4 08 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 CORTO pdf2rtf.004297B0` Let's analyze it: Vamos a analizar es el siguiente: [quote] 1st line --> move the address of the function MSVCRT.atoi to EDI 1 ª línea -> Mover la dirección de la función MSVCRT.atoi a EDI atoi is a function which converts ASCII characters to integers (numbers). atoi es una función que convierte los caracteres ASCII para enteros (números). 2nd line --> put the 16th byte of our serial into EDI 2 ª línea -> poner el 16 byte de nuestra serie en EDI 3rd line --> push our byte to the stack as an argument to atoi 3 ª línea -> empujar nuestro byte en la pila como un argumento para atoi 4th line --> call atoi. 4 ª línea -> llamada atoi. the result will be in EAX el resultado será en EAX 5th line --> move content of EAX into EBP 5 ª línea -> mover el contenido de EAX en EBP 6th line --> move the first byte of our serial into EAX 6 ª línea -> mover el primer byte de nuestra serie en EAX 7th line --> push our byte to the stack as an argument to atoi 7 ª línea -> empujar nuestro byte en la pila como un argumento para atoi 8th line --> call atoi. 8 ª línea -> llamada atoi. the result will be in EAX el resultado será en EAX 9th line --> add EAX to EBP and store the result in EBP 9 ª línea -> EAX añadir a EBP y almacenar el resultado en EBP 10th line --> not important to us 10a línea -> no es importante para nosotros 11th line --> compare EBX with the value 0x0A (10) Línea 11 -> EBX comparar con el valor 0x0A (10) 12th line --> if EBX is not 0x0A then jump to 004297B0 (put 0 into EAX and return). 12 ª línea -> EBX si no es 0x0A después salta a 004297B0 (0 poner en EAX y vuelta). [/quote] [/ quote] NOTE: You probably wonder how i figured out which byte is used to put into atoi, well here NOTA: Usted probablemente se preguntará cómo me imaginé que fuera byte se utiliza para poner en atoi, así aquí it is: I've put in serials multiple times with different digits as values and compared them to es: He puesto en series múltiples veces con diferentes dígitos como los valores y en comparación a the output of atoi in EAX. la de atoi salida en EAX. This resulted in the corresponding bytes. Esto dio lugar a la correspondiente bytes. What do we know from this code? ¿Qué sabemos de este código? - our 16th byte is put into EDI, this means that our serial must be at least 16 characters long - 16a nuestra byte se pone en el EDI, esto significa que nuestra serie debe ser de al menos 16 caracteres de longitud - the 16th byte is put into atoi, which means it much have a value between 0-9 - El 16 byte se pone en atoi, lo que significa que mucho tienen un valor entre 0-9 - the 1st byte is put into atoi as well, which also means it must have a value between 0-9 - El 1 byte se pone en atoi, lo cual también significa que debe tener un valor entre 0-9 - the value of our first byte is added to the value of our 16th byte and together they must be - El valor de nuestro primer byte se añade al valor de nuestro 16o byte y juntos deben equal to 0xA (10). igual a 0xA (10). So now we have the following serial: 1.$............9 Así que ahora tenemos la siguiente serie: 1 .$............ 9 as you can imagine the values of our 1st and 16th byte can be anything as long as they both como usted puede imaginar los valores de nuestra 1 ª y 16 byte puede ser cualquier cosa, siempre y cuando ambos are digits and when added to each other are equal to 10 decimal. son dígitos y cuando se añade a cada uno de los demás son iguales a 10 decimales. Time for the next piece of code: Tiempo para el próximo pedazo de código: CODE : CÓDIGO: `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 PULS ECX` `00429783 \|.` `00429783 \|.` `FFD7 CALL EDI` `FFD7 llamada 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 PULS EDX` `0042978C \|.` `0042978C \|.` `FFD7 CALL EDI` `FFD7 llamada EDI` `0042978E \|.` `0042978E \|.` `03E8 ADD EBP,EAX` `03E8 Añadir EBP, EAX` `00429790 \|.` `00429790 \|.` `83C4 08 ADD ESP,8` `Añadir 83C4 08 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 CORTO pdf2rtf.004297B0` Let's analyze it: Vamos a analizar es el siguiente: [quote] 1st line --> our 15th byte is put into ECX 1 ª línea -> 15a nuestra byte se pone en ECX 2nd line --> push our byte to the stack as an argument to atoi 2 ª línea -> empujar nuestro byte en la pila como un argumento para atoi 3rd line --> call atoi. 3 ª línea -> llamada atoi. the result will be in EAX el resultado será en EAX 4th line --> our 2nd byte is put into EDX 4 ª línea -> 2 ª nuestro byte se pone en EDX 5th line --> move the result of atoi into EBP 5 ª línea -> Mover el resultado de atoi en EBP 6th line --> push our 2nd byte to the stack as an argument to atoi 6 ª línea -> 2 ª empujar nuestro byte en la pila como un argumento para atoi 7th line --> call atoi. 7 ª línea -> llamada atoi. the result will be in EAX el resultado será en EAX 8th line --> add the result of our 15th and 2nd byte together and store in EBP 8 ª línea -> añadir el resultado de nuestra 15 ª y 2 ª byte juntos y en la tienda EBP 9th line --> not important to us. 9 ª línea -> no es importante para nosotros. 10th line --> check if our 15th byte + our 2nd byte added together is equal to 0x0A (10). 10a línea -> comprobar si nuestro 15o bytes + 2 bytes nuestro sumarse es igual a 0x0A (10). 11th line --> if not, then another jump to 004297B0 Línea 11 -> si no es así, entonces otro salto a la 004297B0 [/quote] [/ quote] As you can see this code is very similar to the codeblock before, so i won't explain it any Como puedes ver este código es muy similar a la codeblock antes, por lo que no voy a explicarlo todo further. más lejos. Now we have the following serial: 12$...........89 Ahora tenemos la siguiente serie: 12 $........... 89 We still need to analyze some code, but we're getting somewhere ;-) Todavía tenemos que analizar algo de código, pero estamos recibiendo algún ;-) Lets take a look at the final piece of code from this call: Vamos a echar un vistazo a la última pieza de código a partir de la presente convocatoria: CODE : CÓDIGO: `00429798 \|.` `00429798 \|.` `807E 03 24 CMP BYTE PTR DS:[ESI+3],24` `807E 03 24 CMP BYTE DE PTR DS: [ESI +3], 24` `0042979C \|.` `0042979C \|.` `75 12 JNZ SHORT pdf2rtf.004297B0` `75 12 JNZ CORTO 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 AL SETE` `004297AC \|.` `004297AC \|.` `83C4 30 ADD ESP,30` `83C4 30 Agregar ESP, 30` `004297AF \|.` `004297AF \|.` `C3 RETN` `C3 RETN` Analysis: Análisis: [quote] 1st line --> since ESI still contains our serial, the 4th byte is now checked against value 0x24 1 ª línea -> desde el ESI todavía contiene nuestra serie, el 4 de byte es ahora cotejarse con el valor 0x24 2nd line --> if not equal, then goto the famous 004297B0 2 ª línea -> si no igual, a continuación, ir a la famosa 004297B0 3rd line --> move our 6th byte to CL 3 ª línea -> Mover nuestro byte 6 a CL 4th line --> check if our 6th byte is equal to 0x23 (# sign) 4 ª línea -> comprobar si nuestro 6 º byte es igual a 0x23 (signo #) 5th,6th,7th line --> not important 5 ª, 6 ª, 7 ª línea -> no es importante 8th line --> sets the byte in AL to 1 if our check above is equal 8 ª línea -> establece el byte en AL a 1 si nuestro control es la igualdad de 9th line --> not important 9 ª línea -> no es importante 10th line --> return to where this call was called from. 10a línea -> regreso a la presente convocatoria, donde fue llamado desde. [/quote] [/ quote] What we see here is that our 4th byte is compared to 0x24 ($ sign remember?) as well and that Lo que vemos aquí es que nuestro 4 º byte se compara con 0x24 ($ signo ¿recuerdas?) Como así y que the 6th byte is compared to 0x23 (the # sign). el 6 de byte se compara con 0x23 (el signo #). If that is correct then AL is set to 1 meaning EAX won't be 0 and so causing the program to Si eso es correcto entonces AL se establece en 1 EAX sentido no será el 0 y el fin de causar el programa de give the registered message. a la registrada mensaje. In short: En resumen: -check if 3th == $ -comprobar si == $ 3 de -check if 1st + 16th == 10 comprobar si-1 + 16a == 10 -check if 15th + 2nd == 10 -comprobar si 15o + 2 == 10 -check if 4th == $ -comprobar si == $ 4 -check if 6th == # -comprobar si == # 6 All other characters are of no importance to create a valid serial so our result will be: Todos los demás caracteres no son de importancia para crear una serie válido para que nuestro resultado será el siguiente: 12$$.#........89 12 $$.#........ 89 You can fill in the remaining dots with anything you like and as long as the rules above are Usted puede llenar en el resto de puntos con todo lo que quieras y siempre que las normas están por encima de correct you can change the 1th,2nd,15th and 16th byte as well. correcta puede cambiar el 1th, 2, 15 y 16 así como byte. Now close OllyDbg and start PDF2Word. Ahora estrecho OllyDbg y empezar a PDF2Word. Enter your email-address and enter one of your newly created serials. Ingrese su dirección de correo electrónico y entrar en una de sus series de nueva creación. When you press ok you will be thanked for registering. Si pulsa ok se le agradece de registro. You're welcome ;-) De nada ;-) The result of your entered information is put in a string and written to El resultado de la información introducida se pone en una cadena y por escrito a %WINDIR%system32pdf2word.dat % WINDIR% system32pdf2word.dat In case you want another serial just delete the dat file and put in a new one. En el caso de que quiera otra serie acaba de borrar el archivo DAT y poner en uno nuevo. Of course this is a very simple protection, but it is a nice example to cover the basics of Por supuesto, esta es una protección muy simple, pero es un buen ejemplo para cubrir los elementos básicos de la reverse engineering. ingeniería inversa.
Cast your vote on this article Emitir su voto sobre este artículo Note: the order of the votes has been reversed. Nota: el orden de los votos se ha invertido.

Comments: Comentarios:
Published: 26 comments. Publicado: 26 comentarios.

genocidepromoter - 07:07 am Saturday February 09th, 2008 genocidepromoter - 07:07 horas Sábado 09 de febrero, 2008

lol 10/10 this pwns! lol pwns este 10/10! you should write more :) usted debe escribir más:)

Roy20 - 01:26 pm Saturday February 09th, 2008 Roy20 - 01:26 pm el sábado 09 de febrero, 2008

nice!!!love olly :P 10/10 bonito! OLLY amor: P 10/10

tjszl1 - 09:24 am Sunday February 10th, 2008 tjszl1 - 09:24 horas del domingo 10 de febrero, 2008

Good article!I love you! Buen artículo! Te amo!

lordofwhee - 12:04 pm Sunday February 10th, 2008 lordofwhee - 12:04 pm del domingo 10 de febrero, 2008

Always nice to know this kind of thing. Siempre bueno saber este tipo de cosas. 10/10

Luckyperfect - 02:43 pm Sunday February 10th, 2008 Luckyperfect - 02:43 pm del domingo 10 de febrero, 2008

Good Stuff, Reverse Engineering will get you out of problems or give you a solution to one a lot of times. Good Stuff, Ingeniería Inversa te de problemas o darle una solución a uno un montón de veces.
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. A aprender mucho sobre este artículo, aunque no he podido hacer ver su contenido a la falta de actualización, el PDF2words 1.6 ya no está disponible en la red, todos los espejos y Enlaces descargará la versión 3.0 y la versión actual de ollydgb no tiene la \ "Buscar \" se requiere la opción sobre el paso 2 aparece la bodega Derecho Haga clic en el menú es diferente.
Could you please update the article? ¿Podría usted, por favor, actualice el artículo?
Thank you for knowledge Sir I look forward to learn more from you and your colleagues. Gracias por el conocimiento Sir Espero aprender más de usted y sus colegas.
All the best always... Todo lo mejor siempre ...
-Luckyperfect- -Luckyperfect -
\"Scientia est Potentia\" \ "Scientia est potentia \"

tjszl1 - 07:18 am Tuesday February 12th, 2008 tjszl1 - 07:18 horas Martes 12 de febrero, 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 muy angry.It \' s no es un software.You malicioso puede utilizar el software anti-virus para comprobar que.

white_scorpion - 03:42 pm Wednesday February 13th, 2008 white_scorpion - 03:42 pm Miércoles 13 de febrero, 2008

Donate Donar

Challenges Retos

Get Informed Infórmese

Get Involved ¡Participa!

Communicate Comunicar

About HTS Acerca de HTS

Translate Traducir

Partners Socios