Karpoff Spanish Tutor

Programa:

Visual Buisiness Card v 3.3a


 

PROTECCION: Serial
Descripcion: Para crear tarjetas profesionales creo.
Dificultad: Principiante
DOWNLOAD: http://ourworld.cs.com/rkssoft2/vbc3.exe
Herramientas: Softice, 
CRACKER: Dek_Oin   FECHA: 10/10/2000

 

 introduccion

continuamos la saga de manuales de cracking desde cero. seguimos con el sice. la diferencia con los otros manuales, es que usaremos una técnica diferente y a menudo un poquito más complicada que las demás (solo usando el sice). pues bueno, cualquier cosa que no entiendas mándame un mail (mi dirección está abajo del todo) ya que es posible que les cueste un poco comenzar con esta imprescindible herramienta. los pedidos de cracks serán automáticamente ignorados!!!.

otro programa de la rks software. son excelentes para practicar. será muy fácil encontrar un número de serie, no usaremos la misma técnica que antes aunque sería lo mismo. mejor dicho, no sería lo mismo ya que de esta manera se aprende mucho más que antes. esta vez tracearemos de verdad, con f10, f12 o f11, no se piensen que el sice es así de fácil de utilizar, tiene un montón de comandos que utilizaremos y otro montón de comandos que no utilizaremos. ya tendrán una idea de como será el número de serie (comienza por rks) pero no les ayudará mucho. encontraremos el lugar en el que se realiza la comprobación traceando desde el sice sin poner los típicos break points (de ahora en más bpx) sino que utilizando otra alternativa que siempre funciona. pues a trabajar!!!

 

 al atake

  siempre lo primero que tenemos que hacer es lanzar el symbol loader. recuerdan lo que es?, si no lo recuerdan será mejor que consulten el manual anterior. file/open module y seleccionan el ejecutable de visual buisiness card (vbc.exe). el programa se ejecuta y nos vamos directo al sice. f5 para salir ya que no nos interesa entrar ahora. al ejecutarse el programa nos muestra la misma nag que la del programa del tutorial anterior. hagan clic en "enter serial number" yo pondré los siguientes datos:

nombre: dek_oin

serial: 123456789

        y como era de esperar, la nag más estúpida que he visto (la misma que la del programa anterior). vamos a atacar. [ctrl+d] para entrar al sice y luego ponemos un bpx en hmemcpy

        ustedes se preguntarán ¿que es hmemcpy?. hmemcpy es una api de windows (está en la kernell32.dll) que utiliza la memoria ram para leer, manipular, comparar y almacenar strings (el texto que has introducido en un programa). la función toma la información que has escrito y los pone en la ram. la función procede entonces a manipular estos strings, moviendo y comparándolos (por ejemplo, comparando tú número de serie al correcto), y entonces decide si tu string es correcto o incorrecto. luego esta api envía la información obtenida al programa y éste hace el resto. usando hmemcpy tenemos ventajas y desventajas. la principal ventaja es que pica casi siempre, olvídense de que el bpx no es el correcto, este siempre funciona. la principal desventaja es que a veces es más difícil encontrar el lugar en el cual se realiza la comprobación pero este no es el caso, ya verán.

        primero escribimos los datos y luego escribimos bpx hmemcpy si no se harán un lío tremendo ya que el sice saltará permanentemente. ponemos ok y directamente al sice!!!. si estamos en el sice es porque hmemcpy fue llamada desde algún lugar. les explico:

       recuerdan que hmemcpy se usaba para manipular strings. pues aquí hemos introducido dos strings, el nombre y el serial. como a través de cada nombre se genera un serial, el programa necesita leer el nombre y para ello utiliza hmemcpy. pero el programa también necesita comparar el serial que introducimos con el correcto y para esto también usa hmemcpy. por lo tanto llegamos a la conclusión de que hmemcpy tuvo que ser llamada desde 2 lugares, desde el nombre y desde el serial. estamos en el sice en la primera llamada a  hmemcpy y como no nos interesa seguirle la pista al nombre presionamos f5 para salir del sice hasta que éste se tope con un bpx que hayamos puesto, y verán que el sice vuelve a aparecer inmediatamente. esto es por la segunda llamada a hmemcpy. si exploran un poco la pantalla del sice, verán que estamos en la kernell32.dll y esta zona no nos interesa ya que buscamos el lugar en el cual se realiza la comprobación y es imposible que este lugar sea la dll de kernell32 así que pulsamos f12 para ir a ver quien hizo la llamada a hmemcpy. luego verán que estamos en zonas llamadas user(0a) o user(03) o user (04), esto varía según la computadora y además nos indica que no estamos dentro del ejecutable del programa, sino que estamos en las dll. ¿y qué debíamos hacer para ver quien hizo la llamada a esa zona?. f12, en mi caso lo apreté 6 veces más hasta llegar al ejecutable del programa. aparecerán en un lugar así:

:0042dba5 50               push eax<-------------------------------------el valor de eax en la pila
:0042dba6 e8817afdff       call 0040562c
<-----------------------------llama al mensaje
:0042dbab 85c0             test eax, eax
<-----------compara eax con si mismo (siempre serán iguales)
:0042dbad 7505             jnz 0042dbb4
<-------------------------------nunca saltará aquí (ovbio no?)
:0042dbaf 33c0             xor eax, eax
<-------------------------------eax vale 0 ahora
:0042dbb1 894304           mov dword ptr [ebx+04], eax
<-------byte nº 5 de ebx y lo mete en eax(creo) 
:0042dbb4 8bd3             mov edx, ebx
<-------------------------------edx y ebx valen lo mismo
:0042dbb6 8bc6             mov eax, esi
<-------------------------------eax y esi valen lo mismo
:0042dbb8 e85b98feff       call 00417418
<-----------------------------llamada a hmemcpy
:0042dbbd 5e               pop esi
<--------------------------------aquí aparecemos                 
:0042dbbe 5b               pop ebx
<--------------------------------------ebx fuera de la pila!!!
:0042dbbf c3               ret
<-------------------------------------retorno
:0042dbc0 56               push esi
<-------------------------------------estas otras operaciones no nos
:0042dbc1 8bf0             mov esi, eax                   
servirán para nada.
:0042dbc3 8bc6             mov eax, esi
                       creo que ya pueden describirlas ustedes solitos

 

         esto me huele bien. aquí entramos al lugar en el que se hizo la llamada a hmemcpy y otras operaciones que no nos servirán para nada pero que añadí la descripción para que ya vayan aprendiendo a interpretar el ensamblador. tenemos un retorno cerca da la call y que les parece si nos vamos por esas vías para saber a donde nos conduce el retorno?. vamos a probar...

        tenemos 2 maneras de hacerlo. con f8 entraríamos en todas las call que haya hasta toparnos con un ret. pero con f10 podríamos ir ejecutando el programa paso a paso sin entrar en las call. opto por la segunda opción para no liarnos mucho. en mi caso apreté f10 unas 22 veces creo y llegué a este lugar:

 

:00455458 8b45f4                mov eax, dword ptr [ebp-0c]
:0045545b 8b80b0010000          mov eax, dword ptr [eax+000001b0]
:00455461 e842fffbff            call 004153a8
:00455466 8b45f4                mov eax, dword ptr [ebp-0c]
:00455469 8b88d0010000          mov ecx, dword ptr [eax+000001d0]
:0045546f 8b55f8                mov edx, dword ptr [ebp-08]
:00455472 8b45fc                mov eax, dword ptr [ebp-04]
:00455475 e84e610000            call 0045b5c8
<-llama la rutina de comprobación (entrar con f8 para saber +)
:0045547a 84c0                  test al, al<-------------f10 hasta pararnos   aqui                 

:0045547c 7412                  jz 00455490<---salta al mensaje de error (siempre al=al, siempre saltará)
:0045547e 8b45f4                mov eax, dword ptr [ebp-0c]
<-------------------------estas de abajo
:00455481 c7802801000001000000  mov dword ptr [ebx+00000128], 00000001     
no nos servirán
:0045548b e91b010000           jmp 004555ab                               
para nada
:00455490 55                   push ebp
:00455491 e826fdffff           call 004551bc

        se preguntarán por que no indiqué que son las operaciones que están arriba de la call. estas no tienen casi nada que ver con la comprobación del serial. la call lo hace todo. la call nos lleva a la dirección 0045b5c8 y a partir de esa dirección de memoria se realizan todas las operaciones que comprueban y generan nuestro serial hasta que se topan con un ret (c3 en hexadecimal, significa retorno) que nos conducirá a la operación que estaba después de la call, o sea test al, al. las operaciones test al, al y jz 00455490 se podrían simplificar en un jmp 00455490 (jmp= eb= salta directamente a...)ya que al siempre es igual a si mismo y como salta es salta si es equivalente siempre saltará. esta parte pudo haber confundido a más de uno. por lo tanto presionamos f10 hasta pararnos en test al, al y fíjense el valor de los registros. d eax, d ebx, d ecx, d edx, si!!!!!, bajen un poco en la ventana de datos y verán los dos seriales generados por el programa. 

como dice profesor x, ufffff, creo que este arroz ya se coció!!!

ven que fácil que es usar el sice!!!, nada complicado, aunque no se confíen que este es un programa facilísimo de crackear. me despido pero no sin antes dar las gracias al grupo k-for, a profesor x por su fabulosa compilación y por toda su ayuda, a karpoff, por su gran apoyo y sus consejos, y a txeli, por su apoyo moral y por pasarme algunos programas interesantes, a crkviz (saludos amigo!!!). y finalmente gracias a ustedes por leer mi manual. uyyyy, el arroz se me quemó, me voy rápido!!!!.

y con el arroz del profe ya quemado, saliendo humo y incendiándose mi cocina,

a s t a l a v i s t a


página oficial del grupo k-for: http://pagina.de/kfor
mi dirección de e-mail: dek_oin@hotmail.com

 

karpoff spanish tutor: pagina dedicada a la divulgacion de informacion en castellano, sobre ingenieria inversa y programacion. email "colabora con tus proyectos"
www.000webhost.com