## Tutoríal de Crackeo Para Newbies desde Cero 04/10/99

Por Karpoff ## GRUPO KF_CRACK KARPOFF-NEW 98/99 ##

PROYECTO 13 ##

MemoryDumper V1.0

INTRODUCCION.

Hola a Todos/as, Gracias a todos por el mogollón de emails que he recibido, ha sido una sobrada, parece ser que hay mucha peña que todavía el ProcDump es demasiado, pedís mas manuales sobre programas en listado muerto.

A mi parecer el listado muerto lo hemos tocado en casi todos los manuales, pues aunque hemos utilizado el ProcDump estos han sido estudiados con el W32dasm, además cada dia las protecciones van superándose y cada vez son menos los programas que simplemente se pueden petar con un listado muerto.

Recordáis el los primeros manuales en los que petamos el StayOn Pro y el Stay On the Net, si verdad?? Pues os recomiendo que bajéis la ultima versión de cualquiera de ellos y veáis el cambio que han dado, ahora no nos comeríamos nada solo con el W32dasm, aparentemente el programa no ha cambiado nada pero ya esta a la ultima moda, ejecutable comprimido, protección anti Dasm, anti Debugger y por si fuese poco una vez que libras estas protecciones y sacas un listado muerto no puedes atacar siguiendo cadenas de caracteres porque cuenta con muy pocas y casi todas son de este estilo &&&&###@@@@@.

El programa que he elegido es una herramienta mas que podremos utilizar cuando tengamos mas experiencia se trata de un mapeador de memoria concretamente es Memory Dumper V1.0 se puede bajar de:

http://www.suddendischarge.com/TheFiles/ExecutableTools/memdumpr.zip

 

 

Limitación y comportamiento del programa: el comportamiento del programa es el típico, al ejecutarlo nos da la oportunidad de registrarnos o de utilizarlo en versión shareware, si intentamos registrarnos y fallamos como es normal nos escupe el típico aviso (aunque un poco exagerado) The serial number entered is not valid

Si pasados 30 dias no hemos registrado o petado el programa este deja de funcionar.

Ataques y Herramientas: Ataque mediante el aviso The serial number entered is not valid analizar el proceso que ha hecho que se imprima ese mensaje de fallo en nuestra pantalla y modificar el código en beneficio nuestro, Herramientas simplemente lo que me habéis pedido en los emails el W32dasm y un HEX Edit si hay alguien que no disponga de estas herramientas en mi web las encontrareis.

Currando: Primero como siempre hacer una copia del ejecutable memorydumper.exe para desensamblar el original y editar con el editor HEX la copia, esta copia podemos crearla en el mismo directorio donde esta instalado el original, pero con otro nombre por ejemplo Dumper.exe .

Pues a lo dicho desensamblamos el original MemoryDumper.exe Y con el editor HEX abrimos la copia Dumper.exe bueno ahora deberíamos ver el listado muerto que nos ha hecho el W32dasm y buscar la cadena de caracteres The serial number entered is not valid para buscarla solo tenemos que mirar en String Data Refereces pulsando el botón [Strg-Ref] y enseguida la localizamos porque hay poquitas frases, bueno vemos tanto The serial number entered is not valid como la que nos saldría si el numero de registro seria valido Software has bee Registered Sucessfully esto es una muy buena noticia ya que seguramente nos facilita la localización de la rutina que tendremos que parchear, y por lo general cuanto mas juntitas estén menos código a analizar, una vez mas mis razonamientos al ver este tipo de características son los siguientes,

Tenemos las dos referencias una que no dice que la hemos cagado y la otra que nos felicita bueno en cualquiera de los dos casos los mensajes se imprimen en nuestras pantallas, entonces pensemos que debe de haber una comprobación call test cmp que le diga un salto je jne si tiene que felicitarnos o si tiene que escupirnos dependiendo de si hemos acertado o fallado, objetivo localizar esas rutinas, Donde pueden estar?? Seguramente estarán unas líneas por encima de las cadenas de caracteres (los avisos) Porque unas líneas por encima?? Primero imaginamos que si nuestro je jne recibe el valor que le indica que el numero de registro no es correcto, este salta directo al mensaje de error, dejándose por el camino el mensaje de felicitación, y si el numero de registro es correcto pues será al revés el salto je jne no se ejecuta y continua con la ejecución normal del programa llegando a el mensaje de felicitaciones y sin llegar al mensaje de error. Yo creo que esta muy claro lo que intento explicar.

Pues entonces hagamos doble clip sobre The serial number entered is not valid para ver que parte del código hace que se imprima este aviso, siempre cliqueamos otra vez porque en la mayoría de ocasiones hay varias partes del código que llaman al mismo aviso, en este caso solo hay una referencia a el mensaje de error, y es en:

 

* Reference To: MFC42.Ordinal:0C1A, Ord:0C1Ah

|

:00402EFD E896030000 Call 00403298

:00402F02 8D9538FEFFFF lea edx, dword ptr [ebp+FFFFFE38]

:00402F08 52 push edx

:00402F09 68F0684000 push 004068F0

:00402F0E E8EDF8FFFF call 00402800

:00402F13 83C408 add esp, 00000008

:00402F16 68F0684000 push 004068F0

:00402F1B E806FBFFFF call 00402A26 – RUTINA QUE COMPRUEBA EL REG.

:00402F20 83C404 add esp, 00000004

:00402F23 85C0 test eax, eax

:00402F25 7519 jne 00402F40 – SALTO SOSPECHOSO

:00402F27 6A00 push 00000000

:00402F29 6A00 push 00000000

* Possible StringData Ref from Data Obj ->"The serial number entered is not "->"valid.                               |

:00402F2B 6898654000 push 00406598 --- AQUÍ APARECEMOS

:00402F30 8B8D34FEFFFF mov ecx, dword ptr [ebp+FFFFFE34]

Analicemos en 00402f1b hay una llamada, si seguimos esa llamada seguramente nos llevara paso a paso a las rutinas que van comprobando los datos que hemos metido, según esos datos el retorno(ret) de esa llamada (call) vendrá con un valor que hará que el jne de 00402f25 se ejecute o no, como veis si no se ejecuta va directo al mensaje de error y si se ejecuta podría llegar el mensaje de felicitaciones que esta en 00402fe2

* Possible StringData Ref from Data Obj ->"Software has been registered sucessfully."

|

:00402FE2 68E4674000 push 004067E4

aunque me temo por experiencia que este salto que tenemos localizado lo único que hace si lo partcheamos es mostrarnos el mensaje de felicitaciones, pero sin que el programa se mantenga registrado y si hacéis la prueba veréis que tengo razón,( os recomiendo que probéis, quien sabe igual os estoy engañando. Tenéis que hacer que ese salto se ejecute :-D)

 

Bueno pues si no fuese ese salto analicemos la llamada(call) que parece que se encarga del proceso de comprobación, para ello pulsamos sobre

00402F1B E806FBFFFF call 00402A26

y sobre el botón que pone [call] esto hará que vallamos a la dirección de memoria 00402A26 que parece que es donde se comprueba la validez de nuestro numero.

:00402A26 55 push ebp --CALL nos trae aquí

:00402A27 8BEC mov ebp, esp

:00402A29 81EC44010000 sub esp, 00000144

:00402A2F 56 push esi

:00402A30 57 push edi

:00402A31 8B7508 mov esi, dword ptr [ebp+08]

:00402A34 B950000000 mov ecx, 00000050

:00402A39 8DBDC0FEFFFF lea edi, dword ptr [ebp+FFFFFEC0]

:00402A3F F3 repz

:00402A40 A5 movsd

:00402A41 C785BCFEFFFF00000000 mov dword ptr [ebp+FFFFFEBC], 00000000

:00402A4B EB0F jmp 00402A5C

* Referenced by a (U)nconditional or (C)onditional Jump at Address:

|:00402B27(U)

|

:00402A4D 8B85BCFEFFFF mov eax, dword ptr [ebp+FFFFFEBC]

:00402A53 83C001 add eax, 00000001 Importante que pase por aqui

:00402A56 8985BCFEFFFF mov dword ptr [ebp+FFFFFEBC], eax

* Referenced by a (U)nconditional or (C)onditional Jump at Address:

|:00402A4B(U)

|

:00402A5C 83BDBCFEFFFF40 cmp dword ptr [ebp+FFFFFEBC], 00000040

:00402A63 0F8DC3000000 jnl 00402B2C

:00402A69 8B8DBCFEFFFF mov ecx, dword ptr [ebp+FFFFFEBC]

:00402A6F 8B95BCFEFFFF mov edx, dword ptr [ebp+FFFFFEBC]

:00402A75 8A840DD0FEFFFF mov al, byte ptr [ebp+ecx-00000130]

:00402A7C 3282FC464000 xor al, byte ptr [edx+004046FC]

:00402A82 8B8DBCFEFFFF mov ecx, dword ptr [ebp+FFFFFEBC]

:00402A88 88840DD0FEFFFF mov byte ptr [ebp+ecx-00000130], al

:00402A8F 8B95BCFEFFFF mov edx, dword ptr [ebp+FFFFFEBC]

:00402A95 8B85BCFEFFFF mov eax, dword ptr [ebp+FFFFFEBC]

:00402A9B 8A8C1510FFFFFF mov cl, byte ptr [ebp+edx-000000F0]

:00402AA2 3288FC464000 xor cl, byte ptr [eax+004046FC]

:00402AA8 8B95BCFEFFFF mov edx, dword ptr [ebp+FFFFFEBC]

:00402AAE 888C1510FFFFFF mov byte ptr [ebp+edx-000000F0], cl

:00402AB5 8B85BCFEFFFF mov eax, dword ptr [ebp+FFFFFEBC]

:00402ABB 8B8DBCFEFFFF mov ecx, dword ptr [ebp+FFFFFEBC]

:00402AC1 8A9405D0FEFFFF mov dl, byte ptr [ebp+eax-00000130]

:00402AC8 32940D10FFFFFF xor dl, byte ptr [ebp+ecx-000000F0]

:00402ACF 8B85BCFEFFFF mov eax, dword ptr [ebp+FFFFFEBC]

:00402AD5 889405D0FEFFFF mov byte ptr [ebp+eax-00000130], dl

:00402ADC 8B8DBCFEFFFF mov ecx, dword ptr [ebp+FFFFFEBC]

:00402AE2 8B95BCFEFFFF mov edx, dword ptr [ebp+FFFFFEBC]

:00402AE8 8A840DD0FEFFFF mov al, byte ptr [ebp+ecx-00000130]

:00402AEF 3282FC464000 xor al, byte ptr [edx+004046FC]

:00402AF5 8B8DBCFEFFFF mov ecx, dword ptr [ebp+FFFFFEBC]

:00402AFB 88840DD0FEFFFF mov byte ptr [ebp+ecx-00000130], al

:00402B02 8B95BCFEFFFF mov edx, dword ptr [ebp+FFFFFEBC]

:00402B08 33C0 xor eax, eax

:00402B0A 8A8415D0FEFFFF mov al, byte ptr [ebp+edx-00000130]

:00402B11 8B8DBCFEFFFF mov ecx, dword ptr [ebp+FFFFFEBC]

:00402B17 33D2 xor edx, edx

:00402B19 8A913C474000 mov dl, byte ptr [ecx+0040473C]

:00402B1F 3BC2 cmp eax, edx

:00402B21 7404 je 00402B27 – Nuestro Satto.

:00402B23 33C0 xor eax, eax

:00402B25 EB0A jmp 00402B31

* Referenced by a (U)nconditional or (C)onditional Jump at Address:

|:00402B21(C)

|

:00402B27 E921FFFFFF jmp 00402A4D – Tiene que venir aqui

* Referenced by a (U)nconditional or (C)onditional Jump at Address:

|:00402A63(C)

|

:00402B2C B801000000 mov eax, 00000001

* Referenced by a (U)nconditional or (C)onditional Jump at Address:

|:00402B25(U)

|

:00402B31 5F pop edi

:00402B32 5E pop esi

:00402B33 8BE5 mov esp, ebp

:00402B35 5D pop ebp

:00402B36 C3 ret – El Retorno de la LLamada

bueno aquí esta todo desde el comienzo de la llamada (call) asta el retorno (ret) que nos devolverá a la siguiente línea después de la llamada,

análisis hemos aparecido en 00402A26 55 push ebp a partir de aquí lo que ocurre es esto, el proceso Se dirige a comprobar el numero que hemos metido, seguramente en todas esas instrucciones que hay, se genera el n/s valido y lo compara con el que nosotros hemos puesto y dependiendo de lo que obtenga hará que nos registremos o que fallemos. Bueno la llamada (call) se va ejecutando, enseguida hay un salto incondicional que hará que saltemos 00402A4B EB0F jmp 00402A5C de aquí saltamos a

00402A5C 83BDBCFEFFFF40 cmp dword ptr [ebp+FFFFFEBC], 00000040 –saltamos aquí

00402A63 0F8DC3000000 jnl 00402B2C –bifurcación -que no se ejecuta (otro tipo de salto)

Por lógica la bifurcación que tenemos en 00402a63 no se ejecutara ya que tiene que generar y comprobar el numero de registro en las instrucciones que le siguen. La llamada se sigue ejecutando y llegamos a otro salto en:

00402B21 7404 je 00402B27 –seguramente este será nuestro salto

este es un interesante je que a partir de ahora le llamaremos nuestro salto. veamos que hace si nuestro salto se ejecuta, este nos lleva a

00402B27 E921FFFFFF jmp 00402A4D

que es otro salto en este caso incondicional (jmp siempre salta) que nos sube casi al principio del código de la llamada

:00402A4D 8B85BCFEFFFF mov eax, dword ptr [ebp+FFFFFEBC]- aquí

:00402A53 83C001 add eax, 00000001 Importante que pase por aqui

:00402A56 8985BCFEFFFF mov dword ptr [ebp+FFFFFEBC], eax

Bueno hemos dicho que pasa si se ejecuta 00402B21 7404 je 00402B27 Pero si no se ejecuta que pasa?? Pues fígaros

:00402B21 7404 je 00402B27 – Nuestro Salto.

:00402B23 33C0 xor eax, eax

:00402B25 EB0A jmp 00402B31 – Otro salto incondicional

pues si no se ejecuta enseguida llega a el salto incondicional de 00402b25 como siempre comento un salto incondicional (jmp) siempre salta a la dirección que indique en este caso a 00402b31

:00402B31 5F pop edi – biene de 00402b25 ( el jmp)

:00402B32 5E pop esi

:00402B33 8BE5 mov esp, ebp

:00402B35 5D pop ebp

:00402B36 C3 ret – El Retorno de la Llamada

ya veis que nos lleva a el retorno, y como este seria el proceso que hace si fallamos en el registro debemos modificar algo no?. si el registro falla quiere decir que el flag esta a cero, ósea que tiene que haber una forma de que se ponga el flag a 1. Donde se pone eax a 1??

:00402A53 83C001 add eax, 00000001 -- aquí

00402B2C B801000000 mov eax, 00000001 –- y aquí

Pues para que pase por aquí modifiquemos nuestro salto hagamos que salte :

00402B21 7404 je 00402B27 – Nuestro Salto.

Lo convertimos en un salto incondicional (jmp) Ousease que si lo cambiamos por:

:00402B21 EB04 jmp 00402B27 – Nuestro Salto Manipulado.

Que pasa ahora que hemos convertido el je en un jmp?? Pues que la ejecución del programa al llegar a este punto, salta inmediatamente a

00402B27 E921FFFFFF jmp 00402A4D Que es el salto incondicional (lo hemos visto antes) que nos retorna casi al principio de la llamada (call) que estamos analizando, ahora si cojera los valores que nos interesa ya que al saltar llega a:

:00402A4D 8B85BCFEFFFF mov eax, dword ptr [ebp+FFFFFEBC] aterriza aqui

:00402A53 83C001 add eax, 00000001 coje 1 para EAX

:00402A56 8985BCFEFFFF mov dword ptr [ebp+FFFFFEBC], eax

Y nuevamente llega a la bifurcación que no se ejecuto en un principio , y ahora si se ejecutara ya que ha recogido un 1 para eax, es importante saber que generalmente cuando el flag es uno este hace que se ejecute la instrucción tipo je jne jn etc. Y cuando es 0 sigue la normal ejecución.

00402A5C 83BDBCFEFFFF40 cmp dword ptr [ebp+FFFFFEBC], 00000040

00402A63 0F8DC3000000 jnl 00402B2C –ahora si se ejecuta

Que nos lleva a

:00402B2C B801000000 mov eax, 00000001 --- eax a 1

* Referenced by a (U)nconditional or (C)onditional Jump at Address:

|:00402B25(U)

|

:00402B31 5F pop edi

:00402B32 5E pop esi

:00402B33 8BE5 mov esp, ebp

:00402B35 5D pop ebp

:00402B36 C3 ret – El Retorno de la Llamada

y llega al retorno con el flag a 1 

Bueno coger y analizar todo lo explicado con el código delante, y lo veréis muy fácil, si no quizás no entenderéis todo este proceso.

Solo nos queda aplicar el Patcher que es el siguiente, modificaremos.

00402B21 7404 je 00402B27 Por 00402B21 EB04 jmp 00402B27.

Localizamos el offset de este salto que es 2B21 y vamos al editor Hex que lo tenemos abierto con una copia del ejecutable MemoryDumper.exe y según el editor que estemos utilizando metemos la dirección del offset en buscar y lo que vemos es

7404 y como he dicho lo cambiamos por EB04

SALVAMOS LOS CAMBIOS Y TODO CORRECTO.

Nota: hay varias formas de petar este programa incluso mas fáciles que esta, os recomiendo que os repaséis el código, ya que el manual puede contener errores intencionados con el único objetivo de que entendáis el proceso que analizamos en este programa.

Pues esto es todo. Que os a parecido.. interesante no¿? Como siempre mi mayor deseo es que entendáis esto como yo intento explicarlo.

Un saludo para todos/as (karpoff) hasta el proximo que sera el nº 14

EMAIL: Kf_karpoff@hotmail.com

URL: http://welcome.to/karpoff

http://members.xoom.com/kf_karpoff

El uso de este material es solo para uso educativo, por ahora los cracks son ilegales cada cual es responsable del uso que le de a este tutorial, el autor no se hace responsable de nada.

Tutorial Descargado de Karpoff Spanis Tutor

www.000webhost.com