-[ 0x06 ]-------------------------------------------------------------------
-[ Cracking desde cero ]----------------------------------------------------
-[ D4rkM4s3r ]------------------------------------------------------SET-28--

Nota de los editores:
Este muchacho se ha saltado a la torera las reglas definidas en el apartado
0x07 (reglas ortograficas) !
Caballero, nos tiene sin cuidado que cuando mandes mensajes a tu nueva amante
escribas "q" en lugar de "que" para ahorrarte algunos centimos, pero es que 
e-zine es gratuito !
En fin ! Damos paso a su estilo, pero que no sirva de precedente.

****************************************************************************

DDD    4  4               M   M  4  4   sss  TTTTT  333
D  D   4  4  r rrr  k k   MM MM  4  4  s       T       3  rrrr
D   D  4444  rr     kk    M M M  4444   ss     T    333   rr
D  D      4  r      k k   M   M     4     s    T       3  r
DDD       4  r      k  k  M   M     4  sss     T    333   r


				   ____________________________
				  /============================\
			  	 /******************************\
				|==Cracking desde0 by D4rkM4s3r==|
				 \******************************/
				  \==========e-mail:===========/
				   \==========================/
				    \=d4rkm4st3r@hotmail.com=/
				     \======================/
				      \==XXXXXX-Argentina==/
				       \==================/
					\================/
					 \==============/
		  \============/
		   \==========/
		    \========/
	     \======/
	      \====/
	       \==/
		\/

Salu2 SET desde Argentina! Este es mi primer articulo para una e-zine y mi
primero sobre cracking. En esta seccion aprenderemos un cracking basico
desde window para q to2 los q esten leyendo y tengas ganas de entrar al
"misterioso" mundo del cracking. Vamos a utilizar las herramientas para q
todo cracker debe tener: un debugger, un dissasambler (o las 2 cosas en 1),
un editor hexadecimal, ganas de crackear y 2 ojos en la frente. Por ahora
vamos a utilizar en W32dasm q es un dissasambler/debugger, pero como
debugger vamos a utilizar el OllyDBG. El editor hexadecimal q recomiendo, ya
q tiene buena interface y es facil de usar, y q voy a usar en este curso es
el UltraEdit. Este editor es shareware pero si van aprendiendo van a poderlo
crackear. Todas o la mayoria de las herramientas las encontraran en la
seccion de cracking de www.hackemate.com.ar. Si encuentran otro editor
hexadecimal q encontraron ahi o q tenian antes usenlo. No se si el UltraEdit
esta ahi pero si buscan en www.superarchivos.com o en www.softonic.com q
seguro lo van a encontrar.

Para ir aprendiendo vamos a utilizar crackme's q son para eso, para
crackearlos. Al principio, para los q tengan idea sobre cracking este curso
va a parecerles una boludes pero la dificultad y la emocion iran aumentando
a medida q transcurra los articulos. No podremos presentar articulos de
programas shareware xq no queremos problemas con la ley. Eso no quiere decir
q no lo hagan en sus casas para ir aprendiendo y mejorando, pero por favor
despues borrenlos y desintalenlos para no tener problemas ;D.


*******************************************************************************
*************************************** Indice*********************************
*******************************************************************************

			1*	Sistemas de proteccion
			2*	Como llegar al nucleo de la proteccion
			3*	Sistemas de proteccion por tiempo
			4*	Sistemas de proteccion por Nags
			5*	Sistemas de proteccion por CD-Check							6*	Ensamblador
			7*	Practica: W32dasm
			8*	Practica: OllyDBG
			9*	Concurso
		       10*	Reflexion y despedida (no lo dejen de leer)

*******************************************************************************
**************************** Sistemas de Proteccion****************************
*******************************************************************************

Las principales caracteristicas q deberemos conocer dependeran del tipo de
proteccion q este siendo utilizado, pudiendo ser un sistema de proteccion
combinado (mas de un tipo de proteccion) lo cual puede llegar a complicar el
asunto. Una vez detectado el sistema de proteccion comprobaremos las posibles 
defensas del enemigo. He aqui las defensas q deberemos tener mas en cuenta:

*Anti-Debugging: El software usa tecnicas para detectar nuestra presencia y 
evitar ser trazado (significa correr un fragmento de la aplicacion con un 
debugger). Normalmente Intentara detectar la presencia de un debbuger y parar 
la ejecucion del software mientras este presente.

*Encriptacion/Compresion de datos: El software utiliza tecnicas q ocultan el 
verdadero codigo del programa hasta q se ejecuta, inutilizando asi cualquier 
intento de desamblado del codigo.

Antes de entrar en combate debemos conocer al enemigo. Una vez conocido
debemos seleccionar el armamento adecuado y estaremos listos. Este paso es
importante ya q nos evitara muchos dolores de cabeza si lo realizamos


*******************************************************************************
****************** Como Llegar al nucleo de la proteccion**********************
*******************************************************************************

Cuando estamos trazando un determinado programa podemos utilizar varias tecnicas
para llegar antes a la parte del codigo en la cual sospechamos q puede haber 
parte del sistema de proteccion. Aqui describire algunos de los metodos mas 
usados:

*A lo retro: Se basa en trazar el programa hacia atras, es decir, dejar q el
 sistema de proteccion se active y parar la ejecucion justo despues (cuando
 nos salta un mensaje de error). A partir de este instante trazaremos hacia
 atras buscando un salto q nos aleje o nos aproxime de la funcion q muestra
 el mensaje.

*Por prediccion: Este metodo se utiliza cuando se sospecha de una
 determinada funcion del API de Window$ esta siendo utilizada para el
 funcionamiento del sistema de proteccion. Se pone un breakpoint (significa q
 se detiene es ese breakpoint o bpx) a la funcion q se sospecha esta siendo
 usada y se carga/ continua con la ejecucion del software. A partir de ahi se
 continuara trazando normalmente hasta llegar al punto clave.

*Por referencia a una cadena conocida: Este metodo se usa cuando el
 sistema de proteccion un mensaje de error o un mensaje dentro de un cuadro
 de dialogo. Se copia el mensaje de error, se desambla (aparece el codigo en
 ensamblador) el archivo en el Wdasm, se busca dicha cadena en la lista de
 referencia de cadenas y se hace doble click en esta, se apunta las
 direcciones donde hay una posible referencia y se examina el codigo q hay
 alrededor buscando un salto q nos aleje de la referencia a dicha cadena. Se
 comprueba q sucede si se invierte el salto o preferiblemente se examinan las
 llamadas previas al salto si las hay, ya q estas pueden ser las llamadas q
 comprueban si esta todo en orden (fecha, n de serie, etc).

*Por busqueda de una secuencia de codigos de operacion: Se utiliza
 cuando se sospecha q una determina secuencia de ordenes en ensamblador esta
 siendo utilizada por el sistema de protecion. Conocida la cadena secuencia
 de codigos/bytes a buscar se realiza su busqueda con el editor hexadecimal y
 se opera segun sea el caso.


*******************************************************************************
*********************** Sistemas de Proteccion Por Tiempo**********************
*******************************************************************************

Los sistemas de proteccion por tiempo pueden operar de distintas formas:

*El software COMPRUEBA SI HAN TRANSCURRIDO X CANTIDAD DE DIAS desde la
 instalacion del mismo, y si es asi el software procede a su salida
 inmediata. Durante la salida del software este puede mostrar algun mensaje
 informando al usuario del hecho en cuestion (The Evualuation Period has
 expired).

*El software COMPRUEBA SI HA LLEGADO A UNA FECHA LIMITE, si es asi
 procede de la misma manera q en el caso anterior. La diferencia esta en q el
 software dejara a partir de una fecha determinada y no volvera a funcionar
 si se vuelve a instalar.


*******************************************************************************
************************ Sistema de Proteccion Por Nags************************
*******************************************************************************

Este sistema no es propiamente un sistema de proteccion, sino es un sistema 
para molestar al usuario del software y recordarle q debe adquirir el software 
original. Estas son cuadros de dialogo q aparecen al inicio o al final de la 
aplicacion y estan activos hasta q el usuario un determinado boton o se termina
una cuenta atras.


*******************************************************************************
********************* Sistema de Proteccion Por CD-Check***********************
*******************************************************************************

Este sistema de proteccion comprueba q el CD del software se encuentra en la 
unidad de CD-ROM cada vez q se ejecuta. Estos sistemas no evitan q el CD sea 
duplicado, lo q significa q si introducimos una copia funcionara normalmente. 
Hay dos variantes de este sistema: en el primero identifica al CD-ROM mediante 
la etiqueta q este posee, si el CD tiene la etiqueta esperada continua su 
ejecucion. El segundo metodo se ocupa de comprobar si existe un determinado 
archivo dentro del CD-ROM, si el archivo existe, continua con la ejecucion. La 
dificultad de estos sistemas va aumentando cuando si necesita los datos q hay 
en el CD para poder continuar.


*******************************************************************************
*********************************** Ensamblador********************************
*******************************************************************************

Este lenguaje no es dificil de aprender y no hace falta comprenderlo mucho
para poder crackear. Yo ya he parcheado (significa modificar el codigo para
q haga una cosa diferente al original) varios programas shareware y se lo
basico de este lenguaje. NO voy a explicar en detalle para q sirve cada
cosa, solo lo esencial para poder crackear.

*Empezaremos con los registros; tenemos una serie de registros comunes: con
 algunos de ellos podemos realizar operaciones aritmeticas, movimientos a y
 desde memoria, etc.

 Estos registros son:

 EAX, EBX, ECX, EDX, ESI, EDI, EBP, EIP, ESP.

*Lo siguiente q vamos a aprender es MOV. Su funcion es la transferencia
 de informacion. Esta transferencia puede darse de un registro a otro o entre
 un registro y la memoria (nunca de memoria a memoria), y tambien con valores
 inmediatos teniendo como destino memoria o un registro. Para ello, tendra
 dos operandos; el primero es el de destino y el segundo es el de origen. Asi
 por ejemplo: MOV EAX, EBX. Esta operacion copiara los 32 bits del registro
 EBX en el registro EAX. En HEX = VARIA.

*Tambien es importante la orden CMP, q los q saben ingles se imaginaran
 q es COMPARAR. Esto se presenta asi: CMP EAX, EBX. Esto sirve para comparar
 por ej. el serial valido con nuestro serial. En HEX = VARIA.

*Lo proximo seran los saltos. Hay dos tipos de saltos: los incondicionales y 
 los condicionales.
 La instruccion JMP es la q se utiliza para un salto incondicional; cuando
 se ejecuta la instruccion va a saltar a la direccion indicada. En HEX = EB.
 ej: 0001 JMP 0003	<== se ejecuta
 0002 XXXXXXXX
 0003 XXXXXXXX	<== cae aca

 Los saltos condicionales son los q saltan si se cumple una cierta
 condicion. La forma de actuar es la misma q los JMP. Estos son los mas
 importantes:
 *JZ,  JE:  Salta si es cero, Salta si es igual. En HEX = 74.
 *JNZ, JNE: Salta si no es cero, Salta si no es igual. En HEX = 75.
 *JA:       Salta si es mayor. En HEX = 77.
 *JNA, JBE: Salta si no es mayor, Salta si es menor o igual. En HEX = 76.
 *JNB, JAE: Salta si no es menor, Salta si es mayor o igual. En HEX = 73.

*Otra cosa q hay q saber es el NOP (None-Operation). Esto sirve para q
 no salga un cuadro de dialogo, una nag o q no haga un salto. En HEX = 90.

*Algo q les va a servir es el RET q se utiliza generalmente para volver
 de un call o salto. Se lo nombro xq les sera util para varias cosas. En HEX
 = C3.

*Ademas estan los operadores logicos, los operadores aritmeticos y los Flags.
 Si se quieren profundizar en este codigo de programacion, q lo aconsejo
 (Esto es lo muy basico ;D), busquen la introduccion del Concurso de Narvaja y
 mR gANDALF. Les va a servir un poco mas q el mio :D.


*******************************************************************************
******************************* Practica: W32dasm *****************************
*******************************************************************************

Empezaremos al mundo del cracking con un bonito ejemplo q tiene un nivel
muy bueno para esta primera entrega. El archivo lo podran bajar de
d4rkm4st3r.bravepages.com y es el llamado "Nivel01".   Ahora vamos a
utilizar el W32dasm y el UltraEdit.

1* Lo primero q vamos a hacer es ejecutar el archivo y ver como funciona.
   Ingresamos un nombre y serial cualquiera y vemos q nos aparece una ventana
   de dialogo q dice "No luck there, mate!". Ese mensaje es el q nos va a
   ayudar con el crackeo. Despues hacerle una copia, para usar uno con el
   W32dasm y el otro para usar con el UltraEdit.

2* Abrimos el W32dasm y desamblamos el archivo desde el primer botoncito q
   vemos desde la izquierda o desde Disassembler-Open file to Disassemble. Al
   desamblarlo vemos el codigo en ensamblador, algunas cosas las conocemos,
   otras no, pero no importa, sigamos.

3* Seleccionamos el penultimo boton desde la derecha o desde Refs-String
   Data References, y vemos algunas frases q nos resultan conocidas: No Luck!,
   No luck there, mate! y hay otras como Great Work! y Great Work, mate!. Los
   ultimos como habran adivinado son para cuando ponemos un nombre y serial
   correctos (generalmente solamente el serial importa). Hacemos doble-click
   sobre Great Work! y nos lleva a 40134F (la direccion q vemos a la izquierda
   llamada "Direccion Virtual").

4* Examinamos el codigo mirando para arriba y para abajo, vemos abajo la
   otra parte de la ventana y mas abajo el mensaje de error. Pero nos interesa
   mirar para arriba. Vemos "Reference by a call at address 40124C", esto
   significa q la comprobacion del codigo viene de mas arriba. Para ir a esa
   direccion apretamos el boton q dice "GOTO CD LOC" y ponemos 40124C q es la
   direccion del call.

5* Llegamos y vemos q ese call es la primera orden por eso lo q sigue casi q
   no importa para nuestro objetivo. Arriba vemos "Reference by a Uncondicional
   or Condicional jump at address 401243", esa referencia es de tres ordenes
   mas arriba ;D. Llegamos a 401243 y es un salto condicional JE, arriba vemos
   un CMP eax, ebx. Esto significa q compara nuestro serial con el verdadero. Y
   abajo del salto hay un call q si nos metemos en (nos situamos arriba y
   apretamos el boton q dice "Call"), y llegamos a el mensaje No Luck!.
   Entonces compara nuestro serial con el original y si es igual salta a Great
   Work! sino sigue y llegamos al CALL q nos manda al mensaje de error.
   Entonces para q salte siempre al mensaje Great Work! tenemos q modificar JE
   por JNE para q cuando no son iguales (siempre :D) salte o por JMP para q
   salte siempre

6* Entonces nos posesionamos en el salto y miramos en la barra inferior en
   el medio, veremos q linea es, q pagina, la direccion virtual y lo q nos
   sirve a nosotros, el offset. El offset aparece asi @offset (no se xq aparece
   asi) 00000843h, la hache (h) nos indica q es hexadecimal, lo unico
   importante es el 843. Nos servira a la hora de parchear al programa.

7* Listo. Ya tenemos el offset, entonces vamos al UltraEdit. Lo abrimos,
   clickeamos en Archivo-abrir y seleccionamos la copia q le hicimos al
   programa. Van a aparecer el programita en forma hexadecimal. Pero Nosotros
   tenemos q ir al offset 843, entonces apretamos Ctrl+G y nos aparecera una
   pantalla q dice "Ir a HEX". Nosotros ponemos 0x (para indicarle q vamos a
   ese offset) 843, 0x843. Apretamos ENTER y caeremos en "74 07", q es como
   veran en el W32dasm el mismo codigo q aparece ahi.

8* Lo unico q faltaria es parchearlo. Si queremos q JE cambien por JNE
   cambiamos 74 por 75, q es la famosa 74-75. Y si queremos cambiarlo por JMP
   cambiamos 74 por EB. Listo, lo guardan y prueban el programa parcheado.
   Ponen cualquier nombre y serial y nos aparecera el cartel de Great Work!
   Sientanse felices; es su primer crack.


*******************************************************************************
******************************* Practica: OllyDBG *****************************
*******************************************************************************

Para mejorar nuestros conocimientos dentro mundo del cracking seguiremos
con el ejemplo q utilizamos anteriormente. Pero ahora vamos vamos a utilizar
el OllyDBG y el editor hexadecimal.

1* Lo primero q vamos a hacer es ejecutar el archivo y ver como funciona.
   Ingresamos un nombre y serial cualquiera y vemos q nos aparece una ventana
   de dialogo q dice "No luck there, mate!". Ese mensaje es el q nos va a
   ayudar con el crackeo. Despues hacerle una copia, para usar uno con el
   W32dasm y el otro para usar con el UltraEdit.

2* Abrimos el crackme desde el boton de la carpeta o desde File-Open. Como
   antes veremos el archivo desamblado pero con una interface diferente. Desde
   la izquierda a la derecha vemos la direccion virtual. Le sigue el codigo
   pero en hexadecimal, despues el codigo pero en ensamblador y en la ultima
   veremos informacion adicional como las referencias. Y el chiquitito debajo
   de esos cuatro da informacion tambien. Esos 5 recuadros son los q nos
   interesaran por ahora. Voy a llamarlos por numero; de izquierda a derecha y
   el de abajo (1,2,3,4,5).

3* Seguimos, y hacemos doble-click en alguno de esos 4 cuadros y
   seleccionamos Search for-All referenced text string. Nos aparecera otra
   ventana donde estan todas las referencias. Vemos No Luck! y Great Work! q
   son los titulos de la ventana de dialogo. Hacemos doble-click en "No Luck!"
   y caemos -en la otra ventana- en 40136B.

4* Mas arriba vemos el mensaje bueno, y al lado del codigo en hexa vemos
   unos corchetes. Eso significa q todo lo q esta entre corchetes esta
   relacionado. Subimos hasta el inicio del corchete (401362) y vemos q en el
   cuadro 5 dice "Local call from 401245". Eso quiere decir q el mensaje es
   llamado desde esa direccion. Para llegar hasta ahi podemos ir con la flecha
   o doble-click y seleccionamos Go to-Expression o Ctrl+G.

5* Llegamos a la direccion y observamos hacia abajo y arriba. Uno hacia
   arriba vemos un JE sospechoso, q los q lo crackearon con el W32dasm se
   acordaran. Vemos q salta hacia 3 lineas mas abajo, q es un call. Vemos q el
   call se dirije a 40134D q si vamos el el mensaje bueno.

6* Entonces si cambiamos el salto de 401243 por JMP o JNZ saltaria al
   mensaje de error siempre o con un serial falso. Para esto nos situamos sobre
   el salto y apretamos la barra-espaciadora para modificar el codigo (GUARDA!
   solo se modifica en memoria. Para hacerlo bien hay q usar despues el
   UltraEdit). Tambien se podria hacerlo, mediante doble-click sobre la linea y
   Assemble.

7* No aparecera una ventana con el codigo de la linea y lo unico q hay q
   hacer es cambiar JE por JMP o JNZ. Apretamos F9 para probar los cambios y
   ponemos cualquier nombre y serial, y nos sale el mensaje bueno. Ahora para q
   los cambios sean permanentes, tenemos q modificar el crackme con el
   UltraEdit. Antes de hacerlo, anotamos algunos bytes del codigo (3B C3 74 07
   E8), con esos sera suficiente. Abrimos la copia con el UltraEdit, buscamos
   esos bytes, y modificamos el 74 por EB=JMP o por 75=JNZ. Por las dudas lo
   probamos de vuelta, y si sale el mensaje malo, algo hicieron mal.


*******************************************************************************
************************************ Concurso**********************************
*******************************************************************************

Antes de q salga el proximo numero, van a bajarse el archivo "Nivel02.zip"
desde mi pagina (d4rkm4st3r.bravepages.com) y crackearan los 2 programas
(crackme es hecho por mi :D). Tendran q mandarme al mail
d4rkm4st3r@hotmail.com los siguiente:
	cwcrackme:
1* Diganme la Direccion Virtual del mensaje bueno?Y la Direccion
   Virtual del malo?(ojo q son dos los mensajes).
2* Q Direcciones Virtuales hay q modificar para q salgan los mensajes
   buenos? Tambien diganme los offset de las Direcciones Virtuales.
3* Diganme q modificaron y en q lo modificaron.
4* A lo mejor no le dieron importancia pero sale una NAG dicendo "you
   have to kill me" Q direccion virtual cambian para q no aparezca mas?
   Diganme q modificaron y en q lo modificaron.

	crackme:
1* Diganme la Direccion Virtual del mensaje bueno?Y la Direccion
   Virtual del malo?
2* Q Direccion Virtual hay q modificar para q salgan el mensaje bueno?
   Tambien diganme el offset de la Direccion Virtual.
3* Diganme q modificaron y en q lo modificaron.

Los q me manden la solucion correcta antes q salga en proximo numero seran
mencionados en esta seccion. Cuando me manden el mensaje ponganle su nombre.
Cualquiera q no me ponga el nombre (me entienden q cuando digo nombre es su
seudonimo?) o q me ponga su nombre original no saldra en la lista.
Para los q no pudieron hacerlo aparecera la solucion en el proximo numero.
Crackeenlo con el W32dasm y con el OllyDBG asi aprenden a usar los dos. No
usen solamente uno ya q a veces las referencias de texto no aparecen en el
W32dasm pero si en el OllyDBG.


*******************************************************************************
***************************** Reflexion y Despedida ***************************
*******************************************************************************

Tambien se podria crackear este ejemplo de otras formas.

*En 401241 si cambian CMP EAX,EBX por CMP EAX,EAX les dara el mensaje bueno 
 tambien.
*Otra forma, es Nopear las direcciones 401243-45-4A para q no realice ninguno 
 de los saltos y valla directamente al call q nos lleva al mensaje nuevo.
*Tambien se puede modificar el call, para q en vez de q valla al mensaje
 malo vaya al bueno modificando en 401245: CALL 401362 por CALL 40134D.

Hay varias formas de crackear un programa. No se queden solamente modificando 
los saltos y calls, intenten, investiguen, no sean obsoletos, no sean siempre 
Newbies, MEJOREN.
Cualquier duda, comenterio, criticas, o si hay algo q no entienden o me explique
mal, por favor haganme lo saber al mail q presento al inicio del articulo. Por 
favor es muy importante para mi q me digan mis errores, y si alguien me apoya 
diciendome "buen trabajo segui asi", gracias e intentare ser mejor la proxima.
No encontre ninguna frase de despedida (no busque mucho) asi q esta sera mi 
frase.


				Q La Curiosidad Los Acompanye!

*EOF*